@signalwire/js 3.26.0 → 3.27.0-dev.202404301530.94a97d7.0

package/dist/index.esm.js

@@ -38,117 +38,18 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// src/fabric/index.ts
-var fabric_exports = {};
-__export(fabric_exports, {
-  Client: () => Client2,
-  SWClient: () => SWClient,
-  SignalWire: () => SignalWire,
-  WSClient: () => WSClient
-});
-
-// src/fabric/createHttpClient.ts
-import { AuthError, HttpError } from "@signalwire/core";
-async function http(input, init) {
-  const response = await fetch(input, init);
-  if (!response.ok) {
-    if (response.status === 401) {
-      throw new AuthError(response.status, "Unauthorized");
-    }
-    let errorResponse;
-    try {
-      errorResponse = await response.json();
-    } catch (e) {
-    }
-    const errorMessage = (errorResponse == null ? void 0 : errorResponse.errors) ? JSON.stringify(errorResponse.errors) : "Not Found";
-    throw new HttpError(response.status, errorMessage, errorResponse);
-  }
-  try {
-    response.parsedBody = await response.json();
-  } catch (e) {
-  }
-  return response;
-}
-var createHttpClient = (_a, fetcher = http) => {
-  var _b = _a, { baseUrl, timeout = 3e4 } = _b, globalOptions = __objRest(_b, ["baseUrl", "timeout"]);
-  const apiClient = async (path, options) => {
-    const headers = __spreadValues(__spreadValues(__spreadValues({}, (options == null ? void 0 : options.body) ? { "Content-Type": "application/json" } : {}), globalOptions.headers), options == null ? void 0 : options.headers);
-    const reqInit = getRequestInit(__spreadProps(__spreadValues(__spreadValues({}, globalOptions), options), {
-      headers
-    }));
-    let timerId;
-    if (timeout) {
-      const controller = new AbortController();
-      const signal = controller.signal;
-      reqInit.signal = signal;
-      timerId = setTimeout(() => {
-        controller.abort();
-      }, timeout);
-    }
-    try {
-      const response = await fetcher(getUrl({
-        path,
-        baseUrl,
-        searchParams: options == null ? void 0 : options.searchParams
-      }), reqInit);
-      return { body: response.parsedBody };
-    } catch (e) {
-      throw e;
-    } finally {
-      timerId && clearTimeout(timerId);
-    }
-  };
-  return apiClient;
-};
-var getBody = (body) => {
-  return typeof body === "string" ? body : JSON.stringify(body);
-};
-var getRequestInit = (options) => {
-  return Object.entries(options).reduce((reducer, [key, value]) => {
-    if (key === "body") {
-      return __spreadProps(__spreadValues({}, reducer), {
-        body: getBody(value)
-      });
-    } else if (value != void 0) {
-      return __spreadProps(__spreadValues({}, reducer), {
-        [key]: value
-      });
-    }
-    return reducer;
-  }, {});
-};
-var getUrl = ({
-  path,
-  baseUrl,
-  searchParams
-}) => {
-  const url = new URL(path, baseUrl);
-  if (searchParams) {
-    Object.entries(searchParams).forEach(([key, value]) => {
-      if (value != void 0) {
-        url.searchParams.append(key, value);
-      }
-    });
-  }
-  return url.toString();
-};
-
-// src/video.ts
-var video_exports = {};
-__export(video_exports, {
-  RoomSession: () => RoomSession,
-  createClient: () => createClient,
-  createRoomObject: () => createRoomObject,
-  joinRoom: () => joinRoom
+// src/chat/index.ts
+var chat_exports = {};
+__export(chat_exports, {
+  ChatMember: () => ChatMember,
+  ChatMessage: () => ChatMessage,
+  Client: () => Client2
 });
 
-// src/createRoomObject.ts
-import { getLogger as getLogger13 } from "@signalwire/core";
-
 // src/createClient.ts
 import {
   configureStore,
-  connect as connect3,
+  connect as connect5,
   getEventEmitter
 } from "@signalwire/core";
 
@@ -294,46 +195,6 @@ var setVideoMediaTrack = ({
     element.remove();
   });
 };
-var createRootElementResizeObserver = ({
-  video,
-  rootElement,
-  paddingWrapper
-}) => {
-  const computePaddingWrapperWidth = (width, height) => {
-    const nativeVideoRatio = video.videoWidth / video.videoHeight;
-    const rootElementRatio = width / height;
-    if (nativeVideoRatio > rootElementRatio) {
-      return "100%";
-    } else {
-      return `${height * nativeVideoRatio}px`;
-    }
-  };
-  const maxPaddingBottom = video.videoHeight / video.videoWidth * 100;
-  const update = debounce(({ width, height }) => {
-    if (paddingWrapper) {
-      const pb = height / width * 100;
-      paddingWrapper.style.paddingBottom = `${pb > maxPaddingBottom ? maxPaddingBottom : pb}%`;
-      paddingWrapper.style.width = computePaddingWrapperWidth(width, height);
-    }
-  }, 100);
-  const observer = new ResizeObserver((entries) => {
-    entries.forEach((entry) => {
-      if (entry.contentBoxSize) {
-        const { inlineSize, blockSize } = Array.isArray(entry.contentBoxSize) ? entry.contentBoxSize[0] : entry.contentBoxSize;
-        update({ width: inlineSize, height: blockSize });
-      } else if (entry.contentRect) {
-        update({
-          width: entry.contentRect.width,
-          height: entry.contentRect.height
-        });
-      }
-    });
-  });
-  return {
-    start: () => observer.observe(rootElement),
-    stop: () => observer.disconnect()
-  };
-};
 
 // src/utils/audioElement.ts
 var setAudioMediaTrack = ({
@@ -354,6 +215,44 @@ var setAudioMediaTrack = ({
 import { actions } from "@signalwire/core";
 var audioSetSpeakerAction = actions.createAction("swJs/audioSetSpeakerAction");
 
+// src/utils/aspectRatioListener.ts
+var VIDEO_SIZING_EVENTS = ["loadedmetadata", "resize"];
+function aspectRatioListener({ videoElement, paddingWrapper, fixInLandscapeOrientation = false, debugDivElementId = "videoDimensionsDebug", samplingInterval = 0 }) {
+  const buildHtmlContent = (event, width, height) => `Video dimensions on <strong>${event} event</strong>:</strong> ${width}x${height}px - fixInLandscapeOrientation: ${fixInLandscapeOrientation}`;
+  const appendDebugInfo = (containerElement, event) => {
+    const pEl = document.createElement("p");
+    pEl.innerHTML = buildHtmlContent(event, videoElement.videoWidth, videoElement.videoHeight);
+    containerElement.appendChild(pEl);
+  };
+  let debugElement;
+  try {
+    debugElement = document.getElementById(debugDivElementId);
+  } catch (e) {
+  }
+  VIDEO_SIZING_EVENTS.forEach((event) => videoElement.addEventListener(event, () => {
+    const paddingBottom = fixInLandscapeOrientation ? "56.25" : videoElement.videoHeight / videoElement.videoWidth * 100;
+    paddingWrapper.style.paddingBottom = `${paddingBottom}%`;
+    if (debugElement) {
+      appendDebugInfo(debugElement, event);
+    }
+  }));
+  if (samplingInterval > 0) {
+    setInterval(() => {
+      const paddingBottom = videoElement.videoHeight / videoElement.videoWidth * 100;
+      paddingWrapper.style.paddingBottom = `${paddingBottom}%`;
+      if (debugElement) {
+        let statsElement = debugElement.querySelector(".timer-values");
+        if (!statsElement) {
+          statsElement = document.createElement("div");
+          statsElement.className = "timer-values";
+          debugElement.appendChild(statsElement);
+        }
+        appendDebugInfo(debugElement, "timer");
+      }
+    });
+  }
+}
+
 // src/features/mediaElements/mediaElementsSagas.ts
 var makeVideoElementSaga = ({
   rootElement,
@@ -616,10 +515,14 @@ function* videoElementSetupWorker({
     mcuWrapper.appendChild(element);
     const paddingWrapper = document.createElement("div");
     paddingWrapper.classList.add("paddingWrapper");
-    paddingWrapper.style.paddingBottom = "56.25%";
     paddingWrapper.style.position = "relative";
     paddingWrapper.style.width = "100%";
     paddingWrapper.appendChild(mcuWrapper);
+    aspectRatioListener({
+      videoElement: element,
+      paddingWrapper,
+      fixInLandscapeOrientation: rootElement.classList.contains("landscape-only")
+    });
     const layersWrapper = document.createElement("div");
     layersWrapper.classList.add("mcuLayers");
     layersWrapper.style.display = "none";
@@ -643,17 +546,6 @@ function* videoElementSetupWorker({
       yield sagaEffects.call(waitForVideoReady, { element });
     }
     getLogger2().debug("MCU is ready..");
-    const rootElementResizeObserver = createRootElementResizeObserver({
-      rootElement,
-      video: element,
-      paddingWrapper
-    });
-    rootElementResizeObserver.start();
-    track.addEventListener("ended", () => {
-      if (rootElementResizeObserver) {
-        rootElementResizeObserver.stop();
-      }
-    });
     layersWrapper.style.display = "block";
   } catch (error) {
     getLogger2().error("Handle video track error", error);
@@ -663,7 +555,7 @@ function* videoElementSetupWorker({
 // src/BaseRoomSession.ts
 import {
   connect,
-  Rooms as Rooms6,
+  Rooms as Rooms8,
   extendComponent as extendComponent3,
   LOCAL_EVENT_PREFIX as LOCAL_EVENT_PREFIX2,
   validateEventsToSubscribe as validateEventsToSubscribe2
@@ -1013,6 +905,7 @@ var videoPlaybackWorker = function* (options) {
 
 // src/video/videoWorker.ts
 var videoWorker = function* (options) {
+  getLogger7().trace("videoWorker started");
   const { channels, instance: roomSession } = options;
   const { swEventChannel } = channels;
   function* worker(action) {
@@ -1061,16 +954,91 @@ var videoWorker = function* (options) {
       default:
         break;
     }
-    roomSession.emit(stripNamespacePrefix3(type), payload);
+    const event = stripNamespacePrefix3(type, "video");
+    roomSession.emit(event, payload);
   }
-  const isVideoEvent = (action) => action.type.startsWith("video.");
+  const isVideoOrCallEvent = (action) => {
+    return action.type.startsWith("video.") || action.type.startsWith("call.");
+  };
   while (true) {
-    const action = yield sagaEffects4.take(swEventChannel, isVideoEvent);
+    const action = yield sagaEffects4.take(swEventChannel, isVideoOrCallEvent);
     yield sagaEffects4.fork(worker, action);
   }
   getLogger7().trace("videoWorker ended");
 };
 
+// src/video/videoMemberWorker.ts
+import {
+  Rooms as Rooms6,
+  getLogger as getLogger8,
+  stripNamespacePrefix as stripNamespacePrefix4
+} from "@signalwire/core";
+var videoMemberWorker = function* (options) {
+  var _a, _b;
+  getLogger8().trace("videoMemberWorker started");
+  const {
+    instance: roomSession,
+    callSegments,
+    action: { type, payload },
+    instanceMap: { get, set, remove }
+  } = options;
+  const memberId = ((_a = payload.member) == null ? void 0 : _a.id) || ((_b = payload.member) == null ? void 0 : _b.member_id);
+  let memberInstance = get(memberId);
+  if (!memberInstance) {
+    memberInstance = Rooms6.createRoomSessionMemberObject({
+      store: roomSession.store,
+      payload
+    });
+  } else {
+    memberInstance.setPayload(payload);
+  }
+  set(memberId, memberInstance);
+  let newPayload = __spreadValues({}, payload);
+  const currentCallSegment = callSegments[callSegments.length - 1];
+  if (payload.member.member_id === currentCallSegment.memberId) {
+    newPayload = __spreadProps(__spreadValues({}, payload), {
+      member: __spreadProps(__spreadValues({}, payload.member), {
+        id: roomSession.callSegments[0].memberId,
+        member_id: roomSession.callSegments[0].memberId
+      })
+    });
+  }
+  const event = stripNamespacePrefix4(type);
+  if (type.startsWith("video.member.updated.")) {
+    roomSession.emit(event, newPayload);
+  }
+  switch (type) {
+    case "video.member.joined":
+    case "video.member.updated":
+      roomSession.emit(event, newPayload);
+      break;
+    case "video.member.left":
+      roomSession.emit(event, newPayload);
+      remove(memberId);
+      break;
+    case "video.member.talking":
+      roomSession.emit(event, newPayload);
+      if ("talking" in payload.member) {
+        const suffix = payload.member.talking ? "started" : "ended";
+        roomSession.emit(`${event}.${suffix}`, newPayload);
+        const deprecatedSuffix = payload.member.talking ? "start" : "stop";
+        roomSession.emit(`${event}.${deprecatedSuffix}`, newPayload);
+      }
+      break;
+    default:
+      break;
+  }
+  getLogger8().trace("videoMemberWorker ended");
+};
+
+// src/video/videoRoomWorker.ts
+import {
+  getLogger as getLogger9,
+  Rooms as Rooms7,
+  sagaEffects as sagaEffects5,
+  MemberPosition as MemberPosition2
+} from "@signalwire/core";
+
 // src/BaseRoomSession.ts
 var RoomSessionConnection = class extends BaseConnection3 {
   constructor(options) {
@@ -1080,6 +1048,9 @@ var RoomSessionConnection = class extends BaseConnection3 {
     __publicField(this, "_mirrored");
     __publicField(this, "_audioEl");
     this._mirrored = options.mirrorLocalVideoOverlay;
+    this.initWorker();
+  }
+  initWorker() {
     this.runWorker("videoWorker", {
       worker: videoWorker
     });
@@ -1337,47 +1308,47 @@ var RoomSessionConnection = class extends BaseConnection3 {
   }
 };
 var RoomSessionAPI = extendComponent3(RoomSessionConnection, {
-  audioMute: Rooms6.audioMuteMember,
-  audioUnmute: Rooms6.audioUnmuteMember,
-  videoMute: Rooms6.videoMuteMember,
-  videoUnmute: Rooms6.videoUnmuteMember,
-  deaf: Rooms6.deafMember,
-  undeaf: Rooms6.undeafMember,
-  setInputVolume: Rooms6.setInputVolumeMember,
-  setOutputVolume: Rooms6.setOutputVolumeMember,
-  setMicrophoneVolume: Rooms6.setInputVolumeMember,
-  setSpeakerVolume: Rooms6.setOutputVolumeMember,
-  setInputSensitivity: Rooms6.setInputSensitivityMember,
-  removeMember: Rooms6.removeMember,
-  removeAllMembers: Rooms6.removeAllMembers,
-  getMembers: Rooms6.getMembers,
-  getLayouts: Rooms6.getLayouts,
-  setLayout: Rooms6.setLayout,
-  setPositions: Rooms6.setPositions,
-  setMemberPosition: Rooms6.setMemberPosition,
-  hideVideoMuted: Rooms6.hideVideoMuted,
-  showVideoMuted: Rooms6.showVideoMuted,
-  getRecordings: Rooms6.getRecordings,
-  startRecording: Rooms6.startRecording,
-  getPlaybacks: Rooms6.getPlaybacks,
-  play: Rooms6.play,
-  setHideVideoMuted: Rooms6.setHideVideoMuted,
-  getMeta: Rooms6.getMeta,
-  setMeta: Rooms6.setMeta,
-  updateMeta: Rooms6.updateMeta,
-  deleteMeta: Rooms6.deleteMeta,
-  getMemberMeta: Rooms6.getMemberMeta,
-  setMemberMeta: Rooms6.setMemberMeta,
-  updateMemberMeta: Rooms6.updateMemberMeta,
-  deleteMemberMeta: Rooms6.deleteMemberMeta,
-  promote: Rooms6.promote,
-  demote: Rooms6.demote,
-  getStreams: Rooms6.getStreams,
-  startStream: Rooms6.startStream,
-  lock: Rooms6.lock,
-  unlock: Rooms6.unlock,
-  setRaisedHand: Rooms6.setRaisedHand,
-  setPrioritizeHandraise: Rooms6.setPrioritizeHandraise
+  audioMute: Rooms8.audioMuteMember,
+  audioUnmute: Rooms8.audioUnmuteMember,
+  videoMute: Rooms8.videoMuteMember,
+  videoUnmute: Rooms8.videoUnmuteMember,
+  deaf: Rooms8.deafMember,
+  undeaf: Rooms8.undeafMember,
+  setInputVolume: Rooms8.setInputVolumeMember,
+  setOutputVolume: Rooms8.setOutputVolumeMember,
+  setMicrophoneVolume: Rooms8.setInputVolumeMember,
+  setSpeakerVolume: Rooms8.setOutputVolumeMember,
+  setInputSensitivity: Rooms8.setInputSensitivityMember,
+  removeMember: Rooms8.removeMember,
+  removeAllMembers: Rooms8.removeAllMembers,
+  getMembers: Rooms8.getMembers,
+  getLayouts: Rooms8.getLayouts,
+  setLayout: Rooms8.setLayout,
+  setPositions: Rooms8.setPositions,
+  setMemberPosition: Rooms8.setMemberPosition,
+  hideVideoMuted: Rooms8.hideVideoMuted,
+  showVideoMuted: Rooms8.showVideoMuted,
+  getRecordings: Rooms8.getRecordings,
+  startRecording: Rooms8.startRecording,
+  getPlaybacks: Rooms8.getPlaybacks,
+  play: Rooms8.play,
+  setHideVideoMuted: Rooms8.setHideVideoMuted,
+  getMeta: Rooms8.getMeta,
+  setMeta: Rooms8.setMeta,
+  updateMeta: Rooms8.updateMeta,
+  deleteMeta: Rooms8.deleteMeta,
+  getMemberMeta: Rooms8.getMemberMeta,
+  setMemberMeta: Rooms8.setMemberMeta,
+  updateMemberMeta: Rooms8.updateMemberMeta,
+  deleteMemberMeta: Rooms8.deleteMemberMeta,
+  promote: Rooms8.promote,
+  demote: Rooms8.demote,
+  getStreams: Rooms8.getStreams,
+  startStream: Rooms8.startStream,
+  lock: Rooms8.lock,
+  unlock: Rooms8.unlock,
+  setRaisedHand: Rooms8.setRaisedHand,
+  setPrioritizeHandraise: Rooms8.setPrioritizeHandraise
 });
 var createBaseRoomSessionObject = (params) => {
   const room = connect({
@@ -1396,16 +1367,16 @@ import {
 } from "@signalwire/core";
 
 // src/cantina/workers/videoManagerWorker.ts
-import { getLogger as getLogger10, sagaEffects as sagaEffects5 } from "@signalwire/core";
+import { getLogger as getLogger12, sagaEffects as sagaEffects6 } from "@signalwire/core";
 
 // src/cantina/workers/videoManagerRoomsWorker.ts
 import {
-  getLogger as getLogger8,
+  getLogger as getLogger10,
   toExternalJSON,
-  stripNamespacePrefix as stripNamespacePrefix4
+  stripNamespacePrefix as stripNamespacePrefix5
 } from "@signalwire/core";
 var videoManagerRoomsWorker = function* (options) {
-  getLogger8().trace("videoManagerRoomsWorker started");
+  getLogger10().trace("videoManagerRoomsWorker started");
   const {
     instance: client,
     action: { type, payload }
@@ -1413,29 +1384,29 @@ var videoManagerRoomsWorker = function* (options) {
   const modPayload = {
     rooms: payload.rooms.map((row) => toExternalJSON(row))
   };
-  client.emit(stripNamespacePrefix4(type), modPayload);
-  getLogger8().trace("videoManagerRoomsWorker ended");
+  client.emit(stripNamespacePrefix5(type), modPayload);
+  getLogger10().trace("videoManagerRoomsWorker ended");
 };
 
 // src/cantina/workers/videoManagerRoomWorker.ts
 import {
-  getLogger as getLogger9,
+  getLogger as getLogger11,
   toExternalJSON as toExternalJSON2,
-  stripNamespacePrefix as stripNamespacePrefix5
+  stripNamespacePrefix as stripNamespacePrefix6
 } from "@signalwire/core";
 var videoManagerRoomWorker = function* (options) {
-  getLogger9().trace("videoManagerRoomWorker started");
+  getLogger11().trace("videoManagerRoomWorker started");
   const {
     instance: client,
     action: { type, payload }
   } = options;
-  client.emit(stripNamespacePrefix5(type), toExternalJSON2(payload));
-  getLogger9().trace("videoManagerRoomWorker ended");
+  client.emit(stripNamespacePrefix6(type), toExternalJSON2(payload));
+  getLogger11().trace("videoManagerRoomWorker ended");
 };
 
 // src/cantina/workers/videoManagerWorker.ts
 var videoManagerWorker = function* (options) {
-  getLogger10().trace("videoManagerWorker started");
+  getLogger12().trace("videoManagerWorker started");
   const {
     channels: { swEventChannel }
   } = options;
@@ -1443,7 +1414,7 @@ var videoManagerWorker = function* (options) {
     const { type } = action;
     switch (type) {
       case "video-manager.rooms.subscribed":
-        yield sagaEffects5.fork(videoManagerRoomsWorker, __spreadValues({
+        yield sagaEffects6.fork(videoManagerRoomsWorker, __spreadValues({
           action
         }, options));
         break;
@@ -1452,22 +1423,22 @@ var videoManagerWorker = function* (options) {
       case "video-manager.room.ended":
       case "video-manager.room.started":
       case "video-manager.room.updated":
-        yield sagaEffects5.fork(videoManagerRoomWorker, __spreadValues({
+        yield sagaEffects6.fork(videoManagerRoomWorker, __spreadValues({
           action
         }, options));
         break;
       default:
-        getLogger10().warn(`Unknown video-manager event: "${type}"`);
+        getLogger12().warn(`Unknown video-manager event: "${type}"`);
         break;
     }
   }
   while (true) {
-    const action = yield sagaEffects5.take(swEventChannel, (action2) => {
+    const action = yield sagaEffects6.take(swEventChannel, (action2) => {
       return action2.type.startsWith("video-manager.");
     });
-    yield sagaEffects5.fork(worker, action);
+    yield sagaEffects6.fork(worker, action);
   }
-  getLogger10().trace("videoManagerWorker ended");
+  getLogger12().trace("videoManagerWorker ended");
 };
 
 // src/cantina/VideoManager.ts
@@ -1501,105 +1472,77 @@ var createVideoManagerObject = (params) => {
   return proxy;
 };
 
-// src/Client.ts
-var ClientAPI = class extends BaseClient {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "_videoManager");
-    __publicField(this, "_chat");
-    __publicField(this, "_pubSub");
-  }
-  get rooms() {
-    return {
-      makeRoomObject: (makeRoomOptions) => {
-        const _a = makeRoomOptions, {
-          rootElement,
-          applyLocalVideoOverlay = true,
-          stopCameraWhileMuted = true,
-          stopMicrophoneWhileMuted = true
-        } = _a, options = __objRest(_a, [
-          "rootElement",
-          "applyLocalVideoOverlay",
-          "stopCameraWhileMuted",
-          "stopMicrophoneWhileMuted"
-        ]);
-        const customSagas = [];
-        customSagas.push(makeAudioElementSaga({
-          speakerId: options.speakerId
-        }));
-        if (rootElement) {
-          customSagas.push(makeVideoElementSaga({
-            rootElement,
-            applyLocalVideoOverlay
-          }));
-        }
-        const room = createBaseRoomSessionObject(__spreadProps(__spreadValues({}, options), {
-          store: this.store,
-          customSagas
-        }));
-        if (stopMicrophoneWhileMuted) {
-          room.on("member.updated.audio_muted", ({ member }) => {
-            try {
-              if (member.id === room.memberId && "audio_muted" in member) {
-                member.audio_muted ? room.stopOutboundAudio() : room.restoreOutboundAudio();
-              }
-            } catch (error) {
-              this.logger.error("Error handling audio_muted", error);
-            }
-          });
-        }
-        if (stopCameraWhileMuted) {
-          room.on("member.updated.video_muted", ({ member }) => {
-            try {
-              if (member.id === room.memberId && "video_muted" in member) {
-                member.video_muted ? room.stopOutboundVideo() : room.restoreOutboundVideo();
-              }
-            } catch (error) {
-              this.logger.error("Error handling video_muted", error);
-            }
-          });
-        }
-        return room;
+// src/fabric/CallFabricBaseRoomSession.ts
+import {
+  connect as connect4
+} from "@signalwire/core";
+
+// src/fabric/workers/wsClientWorker.ts
+import {
+  getLogger as getLogger13,
+  sagaEffects as sagaEffects7
+} from "@signalwire/core";
+var wsClientWorker = function* (options) {
+  getLogger13().trace("wsClientWorker started");
+  const { channels, initialState } = options;
+  const { swEventChannel } = channels;
+  const { buildInboundCall } = initialState;
+  while (true) {
+    const action = yield sagaEffects7.take(swEventChannel, (action2) => {
+      if (action2.type === "webrtc.message") {
+        return action2.payload.method === "verto.invite";
       }
-    };
-  }
-  get chat() {
-    if (!this._chat) {
-      this._chat = ChatNamespace.createBaseChatObject({
-        store: this.store
-      });
-    }
-    return this._chat;
+      return false;
+    });
+    getLogger13().debug("Receiving a new call over WebSocket", action);
+    buildInboundCall(action.payload.params);
   }
-  get pubSub() {
-    if (!this._pubSub) {
-      this._pubSub = PubSubNamespace.createBasePubSubObject({
-        store: this.store
-      });
-    }
-    return this._pubSub;
-  }
-  get videoManager() {
-    if (!this._videoManager) {
-      this._videoManager = createVideoManagerObject(this.options);
-    }
-    return this._videoManager;
-  }
-  reauthenticate(token) {
-    this.store.dispatch(actions3.reauthAction({ token }));
+  getLogger13().trace("wsClientWorker ended");
+};
+
+// src/fabric/workers/conversationWorker.ts
+import {
+  getLogger as getLogger14,
+  sagaEffects as sagaEffects8
+} from "@signalwire/core";
+var conversationWorker = function* (options) {
+  getLogger14().debug("conversationWorker started");
+  const {
+    channels: { swEventChannel },
+    initialState
+  } = options;
+  const { conversation } = initialState;
+  const isConversationEvent = (action) => {
+    return action.type === "conversation.message";
+  };
+  while (true) {
+    const action = yield sagaEffects8.take(swEventChannel, isConversationEvent);
+    conversation.handleEvent(action.payload);
   }
+  getLogger14().trace("conversationWorker ended");
 };
 
+// src/fabric/workers/unifiedTargetWorker.ts
+import {
+  getLogger as getLogger17,
+  sagaEffects as sagaEffects9
+} from "@signalwire/core";
+
+// src/UnifiedJWTSession.ts
+import {
+  isJSONRPCRequest
+} from "@signalwire/core";
+
 // src/JWTSession.ts
 import jwtDecode2 from "jwt-decode";
 import {
   BaseJWTSession,
-  getLogger as getLogger12
+  getLogger as getLogger16
 } from "@signalwire/core";
 
 // src/utils/storage.ts
 import jwtDecode from "jwt-decode";
-import { getLogger as getLogger11 } from "@signalwire/core";
+import { getLogger as getLogger15 } from "@signalwire/core";
 var getStorage = () => {
   if (window && window.sessionStorage) {
     return window.sessionStorage;
@@ -1614,7 +1557,7 @@ var sessionStorageManager = (token) => {
     roomName = (_a = jwtPayload == null ? void 0 : jwtPayload.r) != null ? _a : "";
   } catch (e) {
     if (process.env.NODE_ENV !== "production") {
-      getLogger11().error("[sessionStorageManager] error decoding JWT", token);
+      getLogger15().error("[sessionStorageManager] error decoding JWT", token);
     }
     roomName = "";
   }
@@ -1641,16 +1584,16 @@ var JWTSession = class extends BaseJWTSession {
       });
     } catch (e) {
       if (process.env.NODE_ENV !== "production") {
-        getLogger12().debug("[JWTSession] error decoding the JWT");
+        getLogger16().debug("[JWTSession] error decoding the JWT");
       }
     }
     super(__spreadProps(__spreadValues({}, options), {
-      host: options.host || (decodedJwt == null ? void 0 : decodedJwt.ch)
+      host: (decodedJwt == null ? void 0 : decodedJwt.ch) || options.host
     }));
     this.options = options;
     __publicField(this, "WebSocketConstructor", WebSocket);
     __publicField(this, "CloseEventConstructor", SwCloseEvent);
-    __publicField(this, "agent", "@signalwire/js/browser/3.26.0");
+    __publicField(this, "agent", "@signalwire/js/browser/3.27.0-dev.202404301530.94a97d7.0");
     __publicField(this, "tokenTyp");
     this.tokenTyp = (_a = decodedJwt.typ) != null ? _a : "VRT";
   }
@@ -1725,6 +1668,532 @@ var JWTSession = class extends BaseJWTSession {
   }
 };
 
+// src/fabric/workers/unifiedEventsWatcher.ts
+import {
+  getLogger as getLogger18,
+  sagaEffects as sagaEffects10,
+  isMappableObject
+} from "@signalwire/core";
+
+// src/fabric/workers/mappers/unifiedEventsMapper.ts
+import { mapObject } from "@signalwire/core";
+
+// src/fabric/workers/callFabricWorker.ts
+import {
+  getLogger as getLogger22,
+  sagaEffects as sagaEffects12
+} from "@signalwire/core";
+
+// src/fabric/workers/callJoinWorker.ts
+import {
+  getLogger as getLogger19,
+  sagaEffects as sagaEffects11,
+  Rooms as Rooms9,
+  MemberPosition as MemberPosition3
+} from "@signalwire/core";
+
+// src/fabric/CallSegment.ts
+import {
+  BaseComponent,
+  connect as connect3
+} from "@signalwire/core";
+var CallSegmentAPI = class extends BaseComponent {
+  constructor(options) {
+    super(options);
+    __publicField(this, "_payload");
+    this._payload = options.payload;
+  }
+  get roomId() {
+    return this._payload.room_id;
+  }
+  get roomSessionId() {
+    return this._payload.room_session_id;
+  }
+  get callId() {
+    return this._payload.call_id;
+  }
+  get memberId() {
+    return this._payload.member_id;
+  }
+  get roomSession() {
+    return this._payload.room_session;
+  }
+  get members() {
+    return this._payload.members;
+  }
+  get member() {
+    var _a;
+    return (_a = this.members) == null ? void 0 : _a.find((member) => member.memberId === this.memberId);
+  }
+  setPayload(payload) {
+    this._payload = payload;
+  }
+};
+var createCallSegmentObject = (params) => {
+  const playback = connect3({
+    store: params.store,
+    Component: CallSegmentAPI
+  })(params);
+  return playback;
+};
+
+// src/fabric/workers/callJoinWorker.ts
+var callJoinWorker = function* (options) {
+  var _a;
+  getLogger19().trace("callJoinWorker started");
+  const { action, callSegments, instanceMap, instance: cfRoomSession } = options;
+  const { payload } = action;
+  const { get, set } = instanceMap;
+  const memberInstances = (_a = payload.room_session.members) == null ? void 0 : _a.map((member) => {
+    let memberInstance = get(member.member_id);
+    if (!memberInstance) {
+      memberInstance = Rooms9.createRoomSessionMemberObject({
+        store: cfRoomSession.store,
+        payload: {
+          room_id: payload.room_id,
+          room_session_id: payload.room_session_id,
+          member
+        }
+      });
+    } else {
+      memberInstance.setPayload({
+        room_id: payload.room_id,
+        room_session_id: payload.room_session_id,
+        member
+      });
+    }
+    set(member.member_id, memberInstance);
+    return memberInstance;
+  });
+  const callSegmentInstance = createCallSegmentObject({
+    store: cfRoomSession.store,
+    payload: __spreadProps(__spreadValues({}, payload), {
+      members: memberInstances
+    })
+  });
+  callSegments.push(callSegmentInstance);
+  cfRoomSession.runWorker("memberPositionWorker", __spreadProps(__spreadValues({
+    worker: MemberPosition3.memberPositionWorker
+  }, options), {
+    instance: cfRoomSession,
+    initialState: payload,
+    dispatcher: function* (subType, subPayload) {
+      yield sagaEffects11.fork(videoMemberWorker, __spreadProps(__spreadValues({}, options), {
+        action: { type: subType, payload: subPayload }
+      }));
+    }
+  }));
+  for (const memberPayload of payload.room_session.members || []) {
+    yield sagaEffects11.fork(videoMemberWorker, __spreadProps(__spreadValues({}, options), {
+      action: {
+        type: "video.member.joined",
+        payload: { member: memberPayload }
+      }
+    }));
+  }
+  cfRoomSession.emit("room.subscribed", payload);
+  cfRoomSession.emit("call.joined", payload);
+  getLogger19().trace("callJoinWorker ended");
+};
+
+// src/fabric/workers/callLeftWorker.ts
+import {
+  getLogger as getLogger20,
+  Rooms as Rooms10
+} from "@signalwire/core";
+var callLeftWorker = function* (options) {
+  getLogger20().trace("callLeftWorker started");
+  const {
+    action: { payload },
+    instance: cfRoomSession,
+    callSegments,
+    instanceMap
+  } = options;
+  const { call_id, room_session_id } = payload;
+  const segmentToRemoveIndex = callSegments.findIndex((segment) => segment.callId == call_id);
+  if (segmentToRemoveIndex >= 0) {
+    callSegments.splice(segmentToRemoveIndex, 1);
+  }
+  instanceMap.getAll().forEach(([key, obj]) => {
+    if (obj instanceof Rooms10.RoomSessionMemberAPI && obj.roomSessionId === room_session_id) {
+      instanceMap.remove(key);
+    }
+  });
+  cfRoomSession.emit("call.left", payload);
+  getLogger20().trace("callLeftWorker ended");
+};
+
+// src/fabric/workers/callStateWorker.ts
+import {
+  getLogger as getLogger21
+} from "@signalwire/core";
+var callStateWorker = function* (options) {
+  getLogger21().trace("callStateWorker started");
+  const {
+    instance: cfRoomSession,
+    action: { payload },
+    callSegments
+  } = options;
+  switch (payload.call_state) {
+    case "ended": {
+      cfRoomSession.emit("call.state", payload);
+      if (callSegments.length < 1 && cfRoomSession.state === "destroy") {
+        console.log(">> destroy");
+        cfRoomSession.destroy();
+      }
+      break;
+    }
+    default:
+      cfRoomSession.emit("call.state", payload);
+      break;
+  }
+  getLogger21().trace("callStateWorker ended");
+};
+
+// src/fabric/workers/callFabricWorker.ts
+var callFabricWorker = function* (options) {
+  getLogger22().trace("callFabricWorker started");
+  const { channels, instance: roomSession } = options;
+  const { swEventChannel } = channels;
+  function* worker(action) {
+    const { type, payload } = action;
+    switch (type) {
+      case "call.joined": {
+        yield sagaEffects12.fork(callJoinWorker, __spreadValues({
+          action
+        }, options));
+        return;
+      }
+      case "call.left": {
+        yield sagaEffects12.fork(callLeftWorker, __spreadValues({
+          action
+        }, options));
+        return;
+      }
+      case "call.state": {
+        yield sagaEffects12.fork(callStateWorker, __spreadValues({
+          action
+        }, options));
+        return;
+      }
+      case "call.started":
+      case "call.updated":
+      case "call.ended": {
+        const action2 = type.split(".")[1];
+        const newEventName = `room.${action2}`;
+        roomSession.emit(newEventName, payload);
+        break;
+      }
+      case "member.joined":
+      case "member.left":
+      case "member.updated":
+      case "member.talking": {
+        const updatedAction = __spreadProps(__spreadValues({}, action), {
+          type: `video.${type}`
+        });
+        yield sagaEffects12.fork(videoMemberWorker, __spreadValues({
+          action: updatedAction
+        }, options));
+        return;
+      }
+      case "layout.changed": {
+        const updatedAction = __spreadProps(__spreadValues({}, action), {
+          type: `video.${type}`
+        });
+        yield sagaEffects12.put(swEventChannel, updatedAction);
+        break;
+      }
+      case "member.demoted":
+      case "member.promoted": {
+        const updatedAction = __spreadProps(__spreadValues({}, action), {
+          type: `video.${type}`
+        });
+        yield sagaEffects12.put(swEventChannel, updatedAction);
+        return;
+      }
+      default:
+        break;
+    }
+    roomSession.emit(type, payload);
+  }
+  const isVideoOrCallEvent = (action) => {
+    return action.type.startsWith("call.") || action.type.startsWith("member.") || action.type.startsWith("layout.");
+  };
+  while (true) {
+    const action = yield sagaEffects12.take(swEventChannel, isVideoOrCallEvent);
+    yield sagaEffects12.fork(worker, action);
+  }
+  getLogger22().trace("callFabricWorker ended");
+};
+
+// src/fabric/CallFabricBaseRoomSession.ts
+var CallFabricRoomSessionConnection = class extends RoomSessionConnection {
+  initWorker() {
+    this.runWorker("callFabricWorker", {
+      worker: callFabricWorker
+    });
+  }
+  get selfMember() {
+    var _a;
+    return (_a = this.callSegments[0]) == null ? void 0 : _a.member;
+  }
+  get targetMember() {
+    var _a;
+    return (_a = this.callSegments[this.callSegments.length - 1]) == null ? void 0 : _a.member;
+  }
+  isSelfMember(id) {
+    return this.callSegments.findIndex((segment) => segment.memberId === id) > -1;
+  }
+  executeAction(params, options = {}) {
+    const { method, extraParams = {} } = params;
+    return this.execute({
+      method,
+      params: __spreadValues({
+        self: {
+          member_id: this.selfMember.id,
+          call_id: this.selfMember.callId,
+          node_id: this.selfMember.nodeId
+        }
+      }, extraParams)
+    }, options);
+  }
+  executeMemberAction(params, options = {}) {
+    const { method, channel, memberId, extraParams = {} } = params;
+    let targetMember = this.targetMember;
+    if (memberId && !this.isSelfMember(memberId)) {
+      const lastSegment = this.callSegments[this.callSegments.length - 1];
+      const memberInCurrentSegment = lastSegment.members.find((member) => member.id === memberId);
+      if (!memberInCurrentSegment) {
+        throw new Error("The memberId is not a part of the current call segment!");
+      } else {
+        targetMember = memberInCurrentSegment;
+      }
+    }
+    return this.execute({
+      method,
+      params: __spreadValues(__spreadProps(__spreadValues({}, channel && { channels: [channel] }), {
+        self: {
+          member_id: this.selfMember.id,
+          call_id: this.selfMember.callId,
+          node_id: this.selfMember.nodeId
+        },
+        target: {
+          member_id: targetMember.id,
+          call_id: targetMember.callId,
+          node_id: targetMember.nodeId
+        }
+      }), extraParams)
+    }, options);
+  }
+  audioMute(params) {
+    return this.executeMemberAction({
+      method: "call.mute",
+      channel: "audio",
+      memberId: params == null ? void 0 : params.memberId
+    });
+  }
+  audioUnmute(params) {
+    return this.executeMemberAction({
+      method: "call.unmute",
+      channel: "audio",
+      memberId: params == null ? void 0 : params.memberId
+    });
+  }
+  videoMute(params) {
+    return this.executeMemberAction({
+      method: "call.mute",
+      channel: "video",
+      memberId: params == null ? void 0 : params.memberId
+    });
+  }
+  videoUnmute(params) {
+    return this.executeMemberAction({
+      method: "call.unmute",
+      channel: "video",
+      memberId: params == null ? void 0 : params.memberId
+    });
+  }
+  deaf(params) {
+    return this.executeMemberAction({
+      method: "call.deaf",
+      memberId: params == null ? void 0 : params.memberId
+    });
+  }
+  undeaf(params) {
+    return this.executeMemberAction({
+      method: "call.undeaf",
+      memberId: params == null ? void 0 : params.memberId
+    });
+  }
+  getLayouts() {
+    return this.executeAction({
+      method: "call.layout.list"
+    }, {
+      transformResolve: (payload) => ({
+        layouts: payload.layouts
+      })
+    });
+  }
+  getMembers() {
+    return this.executeAction({
+      method: "call.member.list"
+    }, {
+      transformResolve: (payload) => ({
+        members: payload.members
+      })
+    });
+  }
+  removeMember(params) {
+    if (!(params == null ? void 0 : params.memberId)) {
+      throw new TypeError('Invalid or missing "memberId" argument');
+    }
+    return this.executeMemberAction({
+      method: "call.member.remove",
+      memberId: params.memberId
+    });
+  }
+  setLayout(params) {
+    const extraParams = {
+      name: params == null ? void 0 : params.name,
+      layout: Object.values((params == null ? void 0 : params.positions) || {})[0]
+    };
+    return this.executeAction({
+      method: "call.layout.set",
+      extraParams
+    });
+  }
+  setInputVolume(params) {
+    return this.executeMemberAction({
+      method: "call.microphone.volume.set",
+      memberId: params == null ? void 0 : params.memberId,
+      extraParams: {
+        volume: params == null ? void 0 : params.volume
+      }
+    });
+  }
+  setOutputVolume(params) {
+    return this.executeMemberAction({
+      method: "video.member.set_output_volume",
+      memberId: params == null ? void 0 : params.memberId,
+      extraParams: {
+        volume: params == null ? void 0 : params.volume
+      }
+    });
+  }
+  setInputSensitivity(params) {
+    return this.executeMemberAction({
+      method: "call.microphone.sensitivity.set",
+      memberId: params == null ? void 0 : params.memberId,
+      extraParams: {
+        value: params == null ? void 0 : params.value
+      }
+    });
+  }
+};
+var createCallFabricBaseRoomSessionObject = (params) => {
+  const room = connect4({
+    store: params.store,
+    customSagas: params.customSagas,
+    Component: CallFabricRoomSessionConnection
+  })(params);
+  return room;
+};
+
+// src/Client.ts
+var ClientAPI = class extends BaseClient {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_videoManager");
+    __publicField(this, "_chat");
+    __publicField(this, "_pubSub");
+  }
+  get rooms() {
+    return {
+      makeRoomObject: (makeRoomOptions) => {
+        const _a = makeRoomOptions, {
+          rootElement,
+          applyLocalVideoOverlay = true,
+          stopCameraWhileMuted = true,
+          stopMicrophoneWhileMuted = true,
+          unifiedEventing = false
+        } = _a, options = __objRest(_a, [
+          "rootElement",
+          "applyLocalVideoOverlay",
+          "stopCameraWhileMuted",
+          "stopMicrophoneWhileMuted",
+          "unifiedEventing"
+        ]);
+        const customSagas = [];
+        customSagas.push(makeAudioElementSaga({
+          speakerId: options.speakerId
+        }));
+        if (rootElement) {
+          customSagas.push(makeVideoElementSaga({
+            rootElement,
+            applyLocalVideoOverlay
+          }));
+        }
+        let roomSessionObject = createBaseRoomSessionObject;
+        if (unifiedEventing) {
+          roomSessionObject = createCallFabricBaseRoomSessionObject;
+        }
+        const room = roomSessionObject(__spreadProps(__spreadValues({}, options), {
+          store: this.store,
+          customSagas
+        }));
+        if (stopMicrophoneWhileMuted) {
+          room.on("member.updated.audio_muted", ({ member }) => {
+            try {
+              if (member.id === room.memberId && "audio_muted" in member) {
+                member.audio_muted ? room.stopOutboundAudio() : room.restoreOutboundAudio();
+              }
+            } catch (error) {
+              this.logger.error("Error handling audio_muted", error);
+            }
+          });
+        }
+        if (stopCameraWhileMuted) {
+          room.on("member.updated.video_muted", ({ member }) => {
+            try {
+              if (member.id === room.memberId && "video_muted" in member) {
+                member.video_muted ? room.stopOutboundVideo() : room.restoreOutboundVideo();
+              }
+            } catch (error) {
+              this.logger.error("Error handling video_muted", error);
+            }
+          });
+        }
+        return room;
+      }
+    };
+  }
+  get chat() {
+    if (!this._chat) {
+      this._chat = ChatNamespace.createBaseChatObject({
+        store: this.store
+      });
+    }
+    return this._chat;
+  }
+  get pubSub() {
+    if (!this._pubSub) {
+      this._pubSub = PubSubNamespace.createBasePubSubObject({
+        store: this.store
+      });
+    }
+    return this._pubSub;
+  }
+  get videoManager() {
+    if (!this._videoManager) {
+      this._videoManager = createVideoManagerObject(this.options);
+    }
+    return this._videoManager;
+  }
+  reauthenticate(token) {
+    this.store.dispatch(actions3.reauthAction({ token }));
+  }
+};
+
 // src/createClient.ts
 var createClient = (userOptions) => {
   const baseUserOptions = __spreadProps(__spreadValues({}, userOptions), {
@@ -1734,14 +2203,208 @@ var createClient = (userOptions) => {
     userOptions: baseUserOptions,
     SessionConstructor: JWTSession
   });
-  const client = connect3({
+  const client = connect5({
     store,
     Component: ClientAPI
   })(baseUserOptions);
   return client;
 };
 
+// src/chat/Client.ts
+var INTERCEPTED_METHODS = [
+  "subscribe",
+  "publish",
+  "getMessages",
+  "getMembers",
+  "getMemberState",
+  "getAllowedChannels",
+  "setMemberState"
+];
+var Client2 = function(chatOptions) {
+  const client = createClient(chatOptions);
+  const createInterceptor = (prop) => {
+    return async (...params) => {
+      await client.connect();
+      return client.chat[prop](...params);
+    };
+  };
+  const interceptors = {
+    _session: client,
+    disconnect: () => client.disconnect()
+  };
+  return new Proxy(client.chat, {
+    get(target, prop, receiver) {
+      if (prop in interceptors) {
+        return interceptors[prop];
+      }
+      if (INTERCEPTED_METHODS.includes(prop)) {
+        return createInterceptor(prop);
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+};
+
+// src/chat/index.ts
+import { ChatMember, ChatMessage } from "@signalwire/core";
+
+// src/pubSub/index.ts
+var pubSub_exports = {};
+__export(pubSub_exports, {
+  Client: () => Client3,
+  PubSubMessage: () => PubSubMessage
+});
+import { PubSub } from "@signalwire/core";
+
+// src/utils/interfaces.ts
+import { INTERNAL_MEMBER_UPDATABLE_PROPS } from "@signalwire/core";
+var INTERNAL_MEMBER_UPDATED_EVENTS = Object.keys(INTERNAL_MEMBER_UPDATABLE_PROPS).map((key) => {
+  return `member.updated.${key}`;
+});
+
+// src/pubSub/Client.ts
+var INTERCEPTED_METHODS2 = [
+  "getAllowedChannels",
+  "subscribe",
+  "publish"
+];
+var Client3 = function(pubSubOptions) {
+  const client = createClient(pubSubOptions);
+  const createInterceptor = (prop) => {
+    return async (...params) => {
+      await client.connect();
+      return client.pubSub[prop](...params);
+    };
+  };
+  const interceptors = {
+    _session: client,
+    disconnect: () => client.disconnect()
+  };
+  return new Proxy(client.pubSub, {
+    get(target, prop, receiver) {
+      if (prop in interceptors) {
+        return interceptors[prop];
+      }
+      if (INTERCEPTED_METHODS2.includes(prop)) {
+        return createInterceptor(prop);
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+};
+
+// src/pubSub/index.ts
+var PubSubMessage = PubSub.PubSubMessage;
+
+// src/fabric/index.ts
+var fabric_exports = {};
+__export(fabric_exports, {
+  Client: () => Client4,
+  ConversationAPI: () => ConversationAPI,
+  HTTPClient: () => HTTPClient,
+  IncomingCallManager: () => IncomingCallManager,
+  SWClient: () => SWClient,
+  SignalWire: () => SignalWire,
+  WSClient: () => WSClient
+});
+
+// src/fabric/createHttpClient.ts
+import { AuthError, HttpError } from "@signalwire/core";
+async function http(input, init) {
+  const response = await fetch(input, init);
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new AuthError(response.status, "Unauthorized");
+    }
+    let errorResponse;
+    try {
+      errorResponse = await response.json();
+    } catch (e) {
+    }
+    const errorMessage = (errorResponse == null ? void 0 : errorResponse.errors) ? JSON.stringify(errorResponse.errors) : "Not Found";
+    throw new HttpError(response.status, errorMessage, errorResponse);
+  }
+  try {
+    response.parsedBody = await response.json();
+  } catch (e) {
+  }
+  return response;
+}
+var createHttpClient = (_a, fetcher = http) => {
+  var _b = _a, { baseUrl, timeout = 3e4 } = _b, globalOptions = __objRest(_b, ["baseUrl", "timeout"]);
+  const apiClient = async (path, options) => {
+    const headers = __spreadValues(__spreadValues(__spreadValues({}, (options == null ? void 0 : options.body) ? { "Content-Type": "application/json" } : {}), globalOptions.headers), options == null ? void 0 : options.headers);
+    const reqInit = getRequestInit(__spreadProps(__spreadValues(__spreadValues({}, globalOptions), options), {
+      headers
+    }));
+    let timerId;
+    if (timeout) {
+      const controller = new AbortController();
+      const signal = controller.signal;
+      reqInit.signal = signal;
+      timerId = setTimeout(() => {
+        controller.abort();
+      }, timeout);
+    }
+    try {
+      const response = await fetcher(getUrl({
+        path,
+        baseUrl,
+        searchParams: options == null ? void 0 : options.searchParams
+      }), reqInit);
+      return { body: response.parsedBody };
+    } catch (e) {
+      throw e;
+    } finally {
+      timerId && clearTimeout(timerId);
+    }
+  };
+  return apiClient;
+};
+var getBody = (body) => {
+  return typeof body === "string" ? body : JSON.stringify(body);
+};
+var getRequestInit = (options) => {
+  return Object.entries(options).reduce((reducer, [key, value]) => {
+    if (key === "body") {
+      return __spreadProps(__spreadValues({}, reducer), {
+        body: getBody(value)
+      });
+    } else if (value != void 0) {
+      return __spreadProps(__spreadValues({}, reducer), {
+        [key]: value
+      });
+    }
+    return reducer;
+  }, {});
+};
+var getUrl = ({
+  path,
+  baseUrl,
+  searchParams
+}) => {
+  const url = new URL(path, baseUrl);
+  if (searchParams) {
+    Object.entries(searchParams).forEach(([key, value]) => {
+      if (value != void 0) {
+        url.searchParams.append(key, value);
+      }
+    });
+  }
+  return url.toString();
+};
+
+// src/video.ts
+var video_exports = {};
+__export(video_exports, {
+  RoomSession: () => RoomSession,
+  createClient: () => createClient,
+  createRoomObject: () => createRoomObject,
+  joinRoom: () => joinRoom
+});
+
 // src/createRoomObject.ts
+import { getLogger as getLogger23 } from "@signalwire/core";
 var VIDEO_CONSTRAINTS = {
   aspectRatio: { ideal: 16 / 9 }
 };
@@ -1780,7 +2443,7 @@ var createRoomObject = (roomOptions) => {
         rootElement = el;
       } else {
         rootElement = document.body;
-        getLogger13().warn(`We couldn't find an element with id: ${rootElementId}: using 'document.body' instead.`);
+        getLogger23().warn(`We couldn't find an element with id: ${rootElementId}: using 'document.body' instead.`);
       }
     }
     const roomObject = client.rooms.makeRoomObject({
@@ -1807,7 +2470,7 @@ var createRoomObject = (roomOptions) => {
           });
           await roomObject.join();
         } catch (error) {
-          getLogger13().error("Join", error);
+          getLogger23().error("Join", error);
           client.disconnect();
           reject2(error);
         }
@@ -1843,11 +2506,11 @@ var joinRoom = (roomOptions) => {
 
 // src/RoomSession.ts
 import {
-  getLogger as getLogger15
+  getLogger as getLogger25
 } from "@signalwire/core";
 
 // src/utils/roomSession.ts
-import { getLogger as getLogger14 } from "@signalwire/core";
+import { getLogger as getLogger24 } from "@signalwire/core";
 var getJoinMediaParams = (options) => {
   const {
     authState,
@@ -1858,7 +2521,7 @@ var getJoinMediaParams = (options) => {
     receiveAudio,
     receiveVideo
   } = options;
-  getLogger14().debug("getJoinMediaParams options", __spreadValues({}, options));
+  getLogger24().debug("getJoinMediaParams options", __spreadValues({}, options));
   const { audio_allowed, video_allowed, join_as } = authState;
   const joinAs = join_as != null ? join_as : "member";
   const canSend = joinAs === "member";
@@ -1871,16 +2534,16 @@ var getJoinMediaParams = (options) => {
   const reqToReceiveAudio = Boolean(receiveAudio != null ? receiveAudio : audio);
   const reqToReceiveVideo = Boolean(receiveVideo != null ? receiveVideo : video);
   if (!canSendAudio && reqToSendAudio) {
-    getLogger14().info("Not allowed to send audio on this room. Default values will be used.");
+    getLogger24().info("Not allowed to send audio on this room. Default values will be used.");
   }
   if (!canSendVideo && reqToSendVideo) {
-    getLogger14().info("Not allowed to send video on this room. Default values will be used.");
+    getLogger24().info("Not allowed to send video on this room. Default values will be used.");
   }
   if (!canReceiveAudio && reqToReceiveAudio) {
-    getLogger14().info("Not allowed to receive video from the room. Default values will be used.");
+    getLogger24().info("Not allowed to receive video from the room. Default values will be used.");
   }
   if (!canReceiveVideo && reqToReceiveVideo) {
-    getLogger14().info("Not allowed to receive video from the room. Default values will be used.");
+    getLogger24().info("Not allowed to receive video from the room. Default values will be used.");
   }
   return {
     mustSendAudio: canSendAudio && reqToSendAudio,
@@ -1975,7 +2638,7 @@ var RoomSession = function(roomOptions) {
   const deprecatedParams = ["audio", "video"];
   deprecatedParams.forEach((param) => {
     if (param in roomOptions) {
-      getLogger15().warn(`The '${param}' parameter on the RoomSession constructor is deprecated. Set it on the '.join()' function instead.`);
+      getLogger25().warn(`The '${param}' parameter on the RoomSession constructor is deprecated. Set it on the '.join()' function instead.`);
     }
   });
   const allowReattach = (roomOptions == null ? void 0 : roomOptions.reattach) !== false;
@@ -2046,7 +2709,7 @@ var RoomSession = function(roomOptions) {
         const audio = (_a2 = params == null ? void 0 : params.audio) != null ? _a2 : audioFromConstructor;
         const video = (_b = params == null ? void 0 : params.video) != null ? _b : videoFromConstructor;
         const authState = client._sessionAuthState;
-        getLogger15().debug("getJoinMediaParams authState?", authState);
+        getLogger25().debug("getJoinMediaParams authState?", authState);
         if (authState && authState.type === "video") {
           const mediaOptions = getJoinMediaParams(__spreadValues({
             authState,
@@ -2059,7 +2722,7 @@ var RoomSession = function(roomOptions) {
 ${JSON.stringify(params, null, 2)}
 `));
           }
-          getLogger15().debug("Set mediaOptions", mediaOptions);
+          getLogger25().debug("Set mediaOptions", mediaOptions);
           room.updateMediaOptions({
             audio: mediaOptions.mustSendAudio ? audio || true : false,
             video: mediaOptions.mustSendVideo ? video || true : false,
@@ -2074,7 +2737,7 @@ ${JSON.stringify(params, null, 2)}
         REQUIRED_EVENTS.forEach((event) => room.once(event, noop2));
         await room.join();
       } catch (error) {
-        getLogger15().error("RoomSession Join", error);
+        getLogger25().error("RoomSession Join", error);
         client.disconnect();
         reject(error);
       }
@@ -2139,7 +2802,7 @@ var buildCall = ({
 };
 
 // src/fabric/Client.ts
-var Client2 = class {
+var Client4 = class {
   constructor(options) {
     this.options = options;
     __publicField(this, "httpClient");
@@ -2255,30 +2918,67 @@ var SWClient = class {
   }
 };
 
-// src/fabric/WSClient.ts
-import { getLogger as getLogger17, VertoSubscribe } from "@signalwire/core";
-
-// src/fabric/WSClientWorker.ts
-import {
-  getLogger as getLogger16,
-  sagaEffects as sagaEffects6
-} from "@signalwire/core";
-var WSClientWorker = function* (options) {
-  getLogger16().debug("WSClientWorker started");
-  const { channels, instance } = options;
-  const { swEventChannel } = channels;
-  getLogger16().debug("WSClientWorker instance", instance);
-  while (true) {
-    const action = yield sagaEffects6.take(swEventChannel, (action2) => {
-      getLogger16().debug("WSClientWorker action", action2);
-      if (action2.type === "webrtc.message") {
-        return action2.payload.method === "verto.invite";
+// src/fabric/WSClient.ts
+import { getLogger as getLogger26, VertoSubscribe, VertoBye } from "@signalwire/core";
+
+// src/fabric/IncomingCallManager.ts
+var IncomingCallManager = class {
+  constructor(_buildCallObject, _executeReject) {
+    this._buildCallObject = _buildCallObject;
+    this._executeReject = _executeReject;
+    __publicField(this, "_pendingInvites", {});
+    __publicField(this, "_handlers", {});
+  }
+  _buildNotification(invite) {
+    const accept = async (params) => {
+      return new Promise((resolve, reject2) => {
+        delete this._pendingInvites[invite.callID];
+        try {
+          const call = this._buildCallObject(invite, params);
+          call.answer();
+          resolve(call);
+        } catch (e) {
+          reject2(e);
+        }
+      });
+    };
+    const reject = () => {
+      delete this._pendingInvites[invite.callID];
+      return this._executeReject(invite.callID, invite.nodeId);
+    };
+    return {
+      invite: {
+        details: invite,
+        accept: (params) => accept(params),
+        reject: () => reject()
       }
-      return false;
-    });
-    getLogger16().debug("Build new call to answer", action);
+    };
+  }
+  setNotificationHandlers(handlers) {
+    this._handlers.all = handlers.all;
+    if (handlers.pushNotification && this._handlers.all != handlers.pushNotification || !handlers.pushNotification) {
+      this._handlers.pushNotification = handlers.pushNotification;
+    }
+    if (handlers.websocket && this._handlers.all != handlers.websocket || !handlers.websocket) {
+      this._handlers.websocket = handlers.websocket;
+    }
+  }
+  handleIncomingInvite(incomingInvite) {
+    var _a, _b;
+    if (incomingInvite.callID in this._pendingInvites) {
+      console.log(`skiping nottification for pending invite to callID: ${incomingInvite.callID}`);
+      return;
+    }
+    this._pendingInvites[incomingInvite.callID] = incomingInvite;
+    if (!(this._handlers.all || this._handlers[incomingInvite.source])) {
+      console.log("skiping nottification no listeners:");
+      return;
+    }
+    const notification = this._buildNotification(incomingInvite);
+    (_b = (_a = this._handlers).all) == null ? void 0 : _b.call(_a, notification);
+    const handler = this._handlers[incomingInvite.source];
+    handler == null ? void 0 : handler(notification);
   }
-  getLogger16().trace("WSClientWorker ended");
 };
 
 // src/fabric/WSClient.ts
@@ -2286,41 +2986,49 @@ var WSClient = class {
   constructor(options) {
     this.options = options;
     __publicField(this, "wsClient");
-    __publicField(this, "logger", getLogger17());
-    this.wsClient = createClient({
-      host: this.options.host,
-      token: this.options.token,
-      debug: {
-        logWsTraffic: true
-      },
-      logLevel: "debug"
-    });
+    __publicField(this, "logger", getLogger26());
+    __publicField(this, "_incomingCallManager");
+    this.wsClient = createClient(__spreadProps(__spreadValues({}, this.options), {
+      unifiedEventing: true
+    }));
+    this._incomingCallManager = new IncomingCallManager((payload, params) => this.buildInboundCall(payload, params), (callId, nodeId) => this.executeVertoBye(callId, nodeId));
   }
-  connect() {
-    this.wsClient.runWorker("WSClientWorker", {
-      worker: WSClientWorker
-    });
-    return this.wsClient.connect();
+  get clientApi() {
+    return this.wsClient;
+  }
+  async connect() {
+    if (!this.wsClient.connected) {
+      this.wsClient.runWorker("wsClientWorker", {
+        worker: wsClientWorker,
+        initialState: {
+          buildInboundCall: (incomingInvite) => this.notifyIncomingInvite("websocket", incomingInvite)
+        }
+      });
+      await this.wsClient.connect();
+    }
   }
   disconnect() {
     return this.wsClient.disconnect();
   }
   async dial(params) {
     return new Promise(async (resolve, reject) => {
+      var _a, _b;
       try {
-        console.log("WSClient dial with:", params);
         await this.connect();
         const call = this.wsClient.rooms.makeRoomObject({
+          audio: (_a = params.audio) != null ? _a : true,
+          video: (_b = params.video) != null ? _b : true,
           negotiateAudio: true,
           negotiateVideo: true,
-          rootElement: this.options.rootElement,
+          rootElement: params.rootElement,
           applyLocalVideoOverlay: true,
           stopCameraWhileMuted: true,
           stopMicrophoneWhileMuted: true,
           destinationNumber: params.to,
           watchMediaPackets: false,
           nodeId: params.nodeId,
-          disableUdpIceServers: this.options.disableUdpIceServers || false
+          disableUdpIceServers: params.disableUdpIceServers || false,
+          unifiedEventing: true
         });
         call.once("destroy", () => {
           this.logger.debug("RTC Connection Destroyed");
@@ -2332,18 +3040,17 @@ var WSClient = class {
         call.start = () => {
           return new Promise(async (resolve2, reject2) => {
             try {
-              call.once("verto.display", () => resolve2(call));
               call.once("room.subscribed", () => resolve2(call));
               await call.join();
             } catch (error) {
-              getLogger17().error("WSClient call start", error);
+              getLogger26().error("WSClient call start", error);
               reject2(error);
             }
           });
         };
         resolve(call);
       } catch (error) {
-        getLogger17().error("WSClient dial", error);
+        getLogger26().error("WSClient dial", error);
         reject(error);
       }
     });
@@ -2368,15 +3075,6 @@ var WSClient = class {
           display_direction
         }
       } = jsonrpc;
-      this.logger.debug("handlePushNotification data", {
-        callID,
-        sdp,
-        caller_id_name,
-        caller_id_number,
-        callee_id_name,
-        callee_id_number,
-        display_direction
-      });
       try {
         await this.connect();
         try {
@@ -2384,29 +3082,46 @@ var WSClient = class {
         } catch (error) {
           this.logger.warn("Verto Subscribe", error);
         }
-        const call = this.wsClient.rooms.makeRoomObject({
-          negotiateAudio: true,
-          negotiateVideo: true,
-          rootElement: this.options.rootElement,
-          applyLocalVideoOverlay: true,
-          stopCameraWhileMuted: true,
-          stopMicrophoneWhileMuted: true,
-          watchMediaPackets: false,
-          remoteSdp: sdp,
-          prevCallId: callID,
+        this.notifyIncomingInvite("pushNotification", {
+          callID,
+          sdp,
+          caller_id_name,
+          caller_id_number,
+          callee_id_name,
+          callee_id_number,
+          display_direction,
           nodeId
         });
-        call.once("destroy", () => {
-          getLogger17().debug("RTC Connection Destroyed");
-        });
-        call.attachPreConnectWorkers();
-        getLogger17().debug("Resolving Call", call);
-        resolve({ resultType: "inboundCall", resultObject: call });
+        resolve({ resultType: "inboundCall" });
       } catch (error) {
         reject(error);
       }
     });
   }
+  notifyIncomingInvite(source, buildCallParams) {
+    this._incomingCallManager.handleIncomingInvite(__spreadValues({
+      source
+    }, buildCallParams));
+  }
+  async executeVertoBye(callId, nodeId) {
+    try {
+      return await this.wsClient.execute({
+        method: "webrtc.verto",
+        params: {
+          callID: callId,
+          node_id: nodeId,
+          message: VertoBye({
+            cause: "USER_BUSY",
+            causeCode: "17",
+            dialogParams: { callID: callId }
+          })
+        }
+      });
+    } catch (error) {
+      this.logger.warn("The call is not available anymore", callId);
+      throw error;
+    }
+  }
   async executeVertoSubscribe(callId, nodeId) {
     try {
       return await this.wsClient.execute({
@@ -2426,6 +3141,33 @@ var WSClient = class {
       throw error;
     }
   }
+  buildInboundCall(payload, params) {
+    var _a, _b;
+    getLogger26().debug("Build new call to answer");
+    const { callID, nodeId, sdp } = payload;
+    const call = this.wsClient.rooms.makeRoomObject({
+      audio: (_a = params.audio) != null ? _a : true,
+      video: (_b = params.video) != null ? _b : true,
+      negotiateAudio: true,
+      negotiateVideo: true,
+      rootElement: params.rootElement,
+      applyLocalVideoOverlay: true,
+      stopCameraWhileMuted: true,
+      stopMicrophoneWhileMuted: true,
+      watchMediaPackets: false,
+      remoteSdp: sdp,
+      prevCallId: callID,
+      nodeId,
+      disableUdpIceServers: params.disableUdpIceServers || false,
+      unifiedEventing: true
+    });
+    call.once("destroy", () => {
+      getLogger26().debug("RTC Connection Destroyed");
+    });
+    call.attachPreConnectWorkers();
+    getLogger26().debug("Resolving Call", call);
+    return call;
+  }
   updateToken(token) {
     return new Promise((resolve, reject) => {
       this.wsClient.once("session.auth_error", (error) => {
@@ -2437,13 +3179,65 @@ var WSClient = class {
       this.wsClient.reauthenticate(token);
     });
   }
+  async online({ incomingCallHandlers }) {
+    this._incomingCallManager.setNotificationHandlers(incomingCallHandlers);
+    await this.connect();
+    return this.wsClient.execute({
+      method: "subscriber.online",
+      params: {}
+    });
+  }
+  offline() {
+    this._incomingCallManager.setNotificationHandlers({});
+    return this.wsClient.execute({
+      method: "subscriber.offline",
+      params: {}
+    });
+  }
 };
 
 // src/fabric/HTTPClient.ts
+import jwtDecode3 from "jwt-decode";
 import {
-  getLogger as getLogger18
+  getLogger as getLogger27
 } from "@signalwire/core";
-import jwtDecode3 from "jwt-decode";
+
+// src/utils/paginatedResult.ts
+function buildPaginatedResult(body, client) {
+  const anotherPage = async (url) => {
+    const { body: body2 } = await client(url);
+    return buildPaginatedResult(body2, client);
+  };
+  return {
+    data: body.data,
+    self: async () => {
+      const { self } = body.links;
+      return self ? anotherPage(self) : void 0;
+    },
+    nextPage: async () => {
+      const { next } = body.links;
+      return next ? anotherPage(next) : void 0;
+    },
+    prevPage: async () => {
+      const { prev } = body.links;
+      return prev ? anotherPage(prev) : void 0;
+    },
+    firstPage: async () => {
+      const { first } = body.links;
+      return first ? anotherPage(first) : void 0;
+    },
+    hasNext: Boolean(body.links.next),
+    hasPrev: Boolean(body.links.prev)
+  };
+}
+
+// src/utils/makeQueryParamsUrl.ts
+function makeQueryParamsUrls(path, queryParams) {
+  const queryString = queryParams.toString();
+  return queryString ? `${path}?${queryString}` : path;
+}
+
+// src/fabric/HTTPClient.ts
 var HTTPClient = class {
   constructor(options) {
     this.options = options;
@@ -2455,6 +3249,9 @@ var HTTPClient = class {
       }
     });
   }
+  get fetch() {
+    return this.httpClient;
+  }
   get httpHost() {
     let decodedJwt = {};
     try {
@@ -2463,7 +3260,7 @@ var HTTPClient = class {
       });
     } catch (e) {
       if (process.env.NODE_ENV !== "production") {
-        getLogger18().debug("[JWTSession] error decoding the JWT");
+        getLogger27().debug("[JWTSession] error decoding the JWT");
       }
     }
     const host = this.options.host || (decodedJwt == null ? void 0 : decodedJwt.ch);
@@ -2472,44 +3269,27 @@ var HTTPClient = class {
     }
     return `fabric.${host.split(".").splice(1).join(".")}`;
   }
+  async getAddress(options) {
+    const { id } = options;
+    let path = `/api/fabric/addresses/${id}`;
+    const { body } = await this.httpClient(path);
+    return body;
+  }
   async getAddresses(options) {
-    const { type, displayName } = options || {};
-    let path = "/addresses";
-    if (type || displayName) {
-      const queryParams = new URLSearchParams();
-      if (type) {
-        queryParams.append("type", type);
-      }
-      if (displayName) {
-        queryParams.append("display_name", displayName);
-      }
-      path += `?${queryParams.toString()}`;
+    const { type, displayName, pageSize } = options || {};
+    let path = "/api/fabric/addresses";
+    const queryParams = new URLSearchParams();
+    if (type) {
+      queryParams.append("type", type);
     }
-    const { body } = await this.httpClient(path);
-    const anotherPage = async (url) => {
-      const { body: body2 } = await this.httpClient(url);
-      return buildResult(body2);
-    };
-    const buildResult = (body2) => {
-      return {
-        addresses: body2.data,
-        nextPage: async () => {
-          const { next } = body2.links;
-          return next ? anotherPage(next) : void 0;
-        },
-        prevPage: async () => {
-          const { prev } = body2.links;
-          return prev ? anotherPage(prev) : void 0;
-        },
-        firstPage: async () => {
-          const { first } = body2.links;
-          return first ? anotherPage(first) : void 0;
-        },
-        hasNext: Boolean(body2.links.next),
-        hasPrev: Boolean(body2.links.prev)
-      };
-    };
-    return buildResult(body);
+    if (displayName) {
+      queryParams.append("display_name", displayName);
+    }
+    if (pageSize) {
+      queryParams.append("page_size", pageSize.toString());
+    }
+    const { body } = await this.httpClient(makeQueryParamsUrls(path, queryParams));
+    return buildPaginatedResult(body, this.httpClient);
   }
   async registerDevice({
     deviceType,
@@ -2531,6 +3311,131 @@ var HTTPClient = class {
       method: "DELETE"
     });
   }
+  async getSubscriberInfo() {
+    let path = "/api/fabric/subscriber/info";
+    const { body } = await this.httpClient(path);
+    return body;
+  }
+};
+
+// src/fabric/ConversationAPI.ts
+var ConversationAPI = class {
+  constructor(conversation, data) {
+    this.conversation = conversation;
+    this.data = data;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get created_at() {
+    return this.data.created_at;
+  }
+  get last_message_at() {
+    return this.data.last_message_at;
+  }
+  get metadata() {
+    return this.data.metadata;
+  }
+  get name() {
+    return this.data.name;
+  }
+  sendMessage(options) {
+    return this.conversation.sendMessage({
+      addressId: this.id,
+      text: options.text
+    });
+  }
+  getMessages(options) {
+    return this.conversation.getConversationMessages(__spreadValues({ addressId: this.id }, options));
+  }
+};
+
+// src/fabric/Conversation.ts
+var Conversation = class {
+  constructor(options) {
+    __publicField(this, "httpClient");
+    __publicField(this, "wsClient");
+    __publicField(this, "callbacks", []);
+    this.httpClient = options.httpClient;
+    this.wsClient = options.wsClient;
+    this.wsClient.clientApi.runWorker("conversationWorker", {
+      worker: conversationWorker,
+      initialState: {
+        conversation: this
+      }
+    });
+  }
+  async sendMessage(options) {
+    try {
+      const { addressId, text } = options;
+      const path = "/api/fabric/messages";
+      const { body } = await this.httpClient.fetch(path, {
+        method: "POST",
+        body: {
+          conversation_id: addressId,
+          text
+        }
+      });
+      return body;
+    } catch (error) {
+      throw new Error("Error sending message to conversation!", error);
+    }
+  }
+  async getConversations(options) {
+    try {
+      const { pageSize } = options || {};
+      const path = "/api/fabric/conversations";
+      const queryParams = new URLSearchParams();
+      if (pageSize) {
+        queryParams.append("page_size", pageSize.toString());
+      }
+      const { body } = await this.httpClient.fetch(makeQueryParamsUrls(path, queryParams));
+      const self = this;
+      const data = body.data.map((conversation) => new ConversationAPI(self, conversation));
+      return buildPaginatedResult(__spreadProps(__spreadValues({}, body), { data }), this.httpClient.fetch);
+    } catch (error) {
+      throw new Error("Error fetching the conversation history!", error);
+    }
+  }
+  async getMessages(options) {
+    try {
+      const { pageSize } = options || {};
+      const path = "/api/fabric/messages";
+      const queryParams = new URLSearchParams();
+      if (pageSize) {
+        queryParams.append("page_size", pageSize.toString());
+      }
+      const { body } = await this.httpClient.fetch(makeQueryParamsUrls(path, queryParams));
+      return buildPaginatedResult(body, this.httpClient.fetch);
+    } catch (error) {
+      throw new Error("Error fetching the conversation messages!", error);
+    }
+  }
+  async getConversationMessages(options) {
+    try {
+      const { addressId, pageSize } = options || {};
+      const path = `/api/fabric/conversations/${addressId}/messages`;
+      const queryParams = new URLSearchParams();
+      if (pageSize) {
+        queryParams.append("page_size", pageSize.toString());
+      }
+      const { body } = await this.httpClient.fetch(makeQueryParamsUrls(path, queryParams));
+      return buildPaginatedResult(body, this.httpClient.fetch);
+    } catch (error) {
+      throw new Error("Error fetching the conversation messages!", error);
+    }
+  }
+  async subscribe(callback) {
+    this.wsClient.connect();
+    this.callbacks.push(callback);
+  }
+  handleEvent(event) {
+    if (this.callbacks.length) {
+      this.callbacks.forEach((callback) => {
+        callback(event);
+      });
+    }
+  }
 };
 
 // src/fabric/SignalWire.ts
@@ -2539,16 +3444,30 @@ var SignalWire = (options) => {
     try {
       const httpClient = new HTTPClient(options);
       const wsClient = new WSClient(options);
+      const conversation = new Conversation({ httpClient, wsClient });
       resolve({
         httpHost: httpClient.httpHost,
-        getAddresses: httpClient.getAddresses.bind(httpClient),
         registerDevice: httpClient.registerDevice.bind(httpClient),
         unregisterDevice: httpClient.unregisterDevice.bind(httpClient),
+        getSubscriberInfo: httpClient.getSubscriberInfo.bind(httpClient),
         connect: wsClient.connect.bind(wsClient),
         disconnect: wsClient.disconnect.bind(wsClient),
+        online: wsClient.online.bind(wsClient),
+        offline: wsClient.offline.bind(wsClient),
         dial: wsClient.dial.bind(wsClient),
         handlePushNotification: wsClient.handlePushNotification.bind(wsClient),
         updateToken: wsClient.updateToken.bind(wsClient),
+        address: {
+          getAddresses: httpClient.getAddresses.bind(httpClient),
+          getAddress: httpClient.getAddress.bind(httpClient)
+        },
+        conversation: {
+          getConversations: conversation.getConversations.bind(conversation),
+          getMessages: conversation.getMessages.bind(conversation),
+          getConversationMessages: conversation.getConversationMessages.bind(conversation),
+          subscribe: conversation.subscribe.bind(conversation),
+          sendMessage: conversation.sendMessage.bind(conversation)
+        },
         __httpClient: httpClient,
         __wsClient: wsClient
       });
@@ -2558,100 +3477,6 @@ var SignalWire = (options) => {
   });
 };
 
-// src/chat/index.ts
-var chat_exports = {};
-__export(chat_exports, {
-  ChatMember: () => ChatMember,
-  ChatMessage: () => ChatMessage,
-  Client: () => Client3
-});
-
-// src/chat/Client.ts
-var INTERCEPTED_METHODS = [
-  "subscribe",
-  "publish",
-  "getMessages",
-  "getMembers",
-  "getMemberState",
-  "getAllowedChannels",
-  "setMemberState"
-];
-var Client3 = function(chatOptions) {
-  const client = createClient(chatOptions);
-  const createInterceptor = (prop) => {
-    return async (...params) => {
-      await client.connect();
-      return client.chat[prop](...params);
-    };
-  };
-  const interceptors = {
-    _session: client,
-    disconnect: () => client.disconnect()
-  };
-  return new Proxy(client.chat, {
-    get(target, prop, receiver) {
-      if (prop in interceptors) {
-        return interceptors[prop];
-      }
-      if (INTERCEPTED_METHODS.includes(prop)) {
-        return createInterceptor(prop);
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-};
-
-// src/chat/index.ts
-import { ChatMember, ChatMessage } from "@signalwire/core";
-
-// src/pubSub/index.ts
-var pubSub_exports = {};
-__export(pubSub_exports, {
-  Client: () => Client4,
-  PubSubMessage: () => PubSubMessage
-});
-import { PubSub } from "@signalwire/core";
-
-// src/utils/interfaces.ts
-import { INTERNAL_MEMBER_UPDATABLE_PROPS } from "@signalwire/core";
-var INTERNAL_MEMBER_UPDATED_EVENTS = Object.keys(INTERNAL_MEMBER_UPDATABLE_PROPS).map((key) => {
-  return `member.updated.${key}`;
-});
-
-// src/pubSub/Client.ts
-var INTERCEPTED_METHODS2 = [
-  "getAllowedChannels",
-  "subscribe",
-  "publish"
-];
-var Client4 = function(pubSubOptions) {
-  const client = createClient(pubSubOptions);
-  const createInterceptor = (prop) => {
-    return async (...params) => {
-      await client.connect();
-      return client.pubSub[prop](...params);
-    };
-  };
-  const interceptors = {
-    _session: client,
-    disconnect: () => client.disconnect()
-  };
-  return new Proxy(client.pubSub, {
-    get(target, prop, receiver) {
-      if (prop in interceptors) {
-        return interceptors[prop];
-      }
-      if (INTERCEPTED_METHODS2.includes(prop)) {
-        return createInterceptor(prop);
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-};
-
-// src/pubSub/index.ts
-var PubSubMessage = PubSub.PubSubMessage;
-
 // src/webrtc.ts
 var webrtc_exports = {};
 __export(webrtc_exports, {