@zyratalk1/zyra-twilio-wrapper 1.2.0

package/dist/index.mjs

@@ -0,0 +1,2002 @@
+// utils/helper.ts
+function createSuccessResult(message, data) {
+  return { success: true, message, data };
+}
+function createErrorResult(error) {
+  return {
+    success: false,
+    error: error instanceof Error ? error : new Error(error)
+  };
+}
+
+// src/react-native-voip-sdk/bridge/event-emitter.ts
+var BridgeEventEmitter = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(eventName, listener) {
+    const set = this.listeners.get(eventName) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this.listeners.set(eventName, set);
+    return () => this.off(eventName, listener);
+  }
+  off(eventName, listener) {
+    const set = this.listeners.get(eventName);
+    if (!set) return;
+    set.delete(listener);
+    if (set.size === 0) {
+      this.listeners.delete(eventName);
+    }
+  }
+  emit(eventName, payload) {
+    const set = this.listeners.get(eventName);
+    if (!set) return;
+    set.forEach((listener) => listener(payload));
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+
+// src/react-native-voip-sdk/bridge/twilio-voice-adapter.ts
+import axios from "axios";
+import { NativeModules, Platform } from "react-native";
+import { Voice } from "@twilio/voice-react-native-sdk";
+var TwilioVoiceAdapter = class {
+  constructor() {
+    this.voice = new Voice();
+    this.axiosInstance = axios.create();
+    this.sdkConfig = null;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.callInvites = /* @__PURE__ */ new Map();
+    this.calls = /* @__PURE__ */ new Map();
+    this.started = false;
+    this.defaultConferenceName = "";
+    this.runtimeAccessToken = null;
+    this.isVoiceRegistered = false;
+  }
+  async initializeSDK(config) {
+    console.log("[VOIP SDK] connect() called");
+    this.sdkConfig = config;
+    this.runtimeAccessToken = config.accessToken ?? null;
+    this.defaultConferenceName = `conf_${config.consumerId}_${Date.now()}`;
+    this.axiosInstance.defaults.baseURL = config.serverUrl;
+    if (!this.started) {
+      this.bindVoiceEvents();
+      this.started = true;
+    }
+    try {
+      const token = this.getVoiceAccessToken();
+      if (!token) {
+        this.emit("onError", {
+          scope: "voice_register",
+          message: "Twilio access token not provided. SDK initialized for config APIs only."
+        });
+        return { success: true, data: {} };
+      }
+      await this.registerVoiceClient(token);
+    } catch (error) {
+      console.error("[VOIP SDK] connect() failed", error);
+      this.emit("onError", {
+        scope: "voice_register",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return { success: true, data: {} };
+  }
+  async authenticate(payload) {
+    console.log("[VOIP SDK] auth started");
+    if (!this.sdkConfig) {
+      return { success: false, error: "SDK not initialized" };
+    }
+    try {
+      this.captureAccessToken(payload);
+      console.log("[VOIP DEBUG] token validation", {
+        hasPayloadToken: Boolean(payload?.accessToken),
+        hasRuntimeToken: Boolean(this.runtimeAccessToken)
+      });
+      const res = await this.axiosInstance.post(
+        `${this.sdkConfig.serverUrl}/voipSdk.verifySdkToken`,
+        payload ?? {},
+        {
+          headers: {
+            Authorization: `Bearer ${this.sdkConfig.sdkToken}`
+          }
+        }
+      );
+      const verified = Boolean(res?.data?.result?.data?.verified);
+      if (!verified) {
+        return { success: false, error: "Invalid SDK token" };
+      }
+      if (!this.getVoiceAccessToken()) {
+        const generatedToken = await this.generateVoiceAccessToken();
+        this.runtimeAccessToken = generatedToken;
+      }
+      const tokenForVoice = this.getVoiceAccessToken();
+      if (tokenForVoice) {
+        try {
+          await this.registerVoiceClient(tokenForVoice);
+        } catch (error) {
+          this.emit("onError", {
+            scope: "voice_register",
+            message: error instanceof Error ? error.message : "Voice register failed after auth"
+          });
+          console.error("[VOIP SDK] voice registration warning after auth", error);
+        }
+      }
+      const auth = {
+        consumerId: this.sdkConfig.consumerId,
+        accessToken: this.getVoiceAccessToken() ?? this.sdkConfig.sdkToken,
+        expiresAt: Date.now() + 55 * 60 * 1e3,
+        scopes: ["voice:call", "voice:conference"]
+      };
+      this.emit("onAuthStateChanged", { state: "AUTHENTICATED" });
+      console.log("[VOIP SDK] auth success");
+      return { success: true, data: auth };
+    } catch (error) {
+      console.error("[VOIP SDK] auth failed", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Authentication failed"
+      };
+    }
+  }
+  async refreshAuth() {
+    if (!this.sdkConfig) {
+      return { success: false, error: "SDK not initialized" };
+    }
+    const auth = {
+      consumerId: this.sdkConfig.consumerId,
+      accessToken: this.getVoiceAccessToken() ?? this.sdkConfig.sdkToken,
+      expiresAt: Date.now() + 55 * 60 * 1e3,
+      scopes: ["voice:call", "voice:conference"]
+    };
+    return { success: true, data: auth };
+  }
+  async startCall(input) {
+    console.log("[VOIP SDK] startCall() invoked", { callId: input.callId, number: input.number });
+    if (!this.sdkConfig) {
+      return { success: false, error: "SDK not initialized" };
+    }
+    try {
+      if (!this.isVoiceNativeModuleAvailable()) {
+        return {
+          success: false,
+          error: "Twilio native module not available (TwilioVoiceReactNative). Rebuild app and verify native linking."
+        };
+      }
+      const token = this.getVoiceAccessToken();
+      if (!token) {
+        return {
+          success: false,
+          error: "Twilio access token missing. Pass accessToken in constructor or authenticate({ accessToken })."
+        };
+      }
+      const conferenceName = `conf_${this.sdkConfig.consumerId}_${input.callId}`;
+      console.log("[VOIP SDK] voice.connect() params", {
+        To: input.number,
+        conferenceName
+      });
+      const call = await this.voice.connect(token, {
+        params: {
+          To: input.number,
+          conferenceName
+        }
+      });
+      const callSid = this.readCallSid(call);
+      const tracked = {
+        callId: input.callId,
+        callSid,
+        call,
+        direction: "OUTBOUND",
+        conferenceName,
+        conferenceDetail: null
+      };
+      this.calls.set(input.callId, tracked);
+      this.bindCallEvents(input.callId, call);
+      console.log("[VOIP SDK] call request sent", { callId: input.callId });
+      const session = {
+        callId: input.callId,
+        direction: "OUTBOUND",
+        status: "DIALING",
+        participants: [],
+        conferenceRoomId: null
+      };
+      return { success: true, data: session };
+    } catch (error) {
+      console.error("[VOIP SDK] startCall() failed", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to start call"
+      };
+    }
+  }
+  async rejectCall(input) {
+    console.log("[VOIP SDK] rejectCall() invoked", { callId: input.callId });
+    const invite = this.callInvites.get(input.callId);
+    if (!invite) {
+      return { success: false, error: "Incoming call invite not found" };
+    }
+    try {
+      if (typeof invite.reject === "function") {
+        await invite.reject();
+      }
+      this.callInvites.delete(input.callId);
+      this.emit("onCallEnded", { callId: input.callId, reason: "rejected" });
+      return { success: true, data: {} };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to reject call"
+      };
+    }
+  }
+  async answerCall(input) {
+    console.log("[VOIP DEBUG] call accepted flow start", { callId: input.callId });
+    try {
+      const invite = this.callInvites.get(input.callId);
+      if (!invite) {
+        return { success: false, error: "Incoming call invite not found" };
+      }
+      const call = await invite.accept();
+      const tracked = {
+        callId: input.callId,
+        callSid: this.readCallSid(call) ?? input.callId,
+        call,
+        direction: "INBOUND",
+        conferenceName: this.defaultConferenceName,
+        conferenceDetail: null
+      };
+      this.calls.set(input.callId, tracked);
+      this.callInvites.delete(input.callId);
+      this.bindCallEvents(input.callId, call);
+      console.log("[VOIP DEBUG] call accepted", { callId: input.callId });
+      return { success: true, data: {} };
+    } catch (error) {
+      console.error("[VOIP DEBUG] call accepted failure", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to answer call"
+      };
+    }
+  }
+  async endCall(input) {
+    console.log("[VOIP SDK] endCall() invoked", { callId: input.callId });
+    const tracked = this.calls.get(input.callId);
+    if (!tracked) return { success: false, error: "Call not found" };
+    try {
+      await tracked.call.disconnect();
+      this.calls.delete(input.callId);
+      this.emit("onCallEnded", { callId: input.callId });
+      console.log("[VOIP SDK] call ended", { callId: input.callId });
+      return { success: true, data: {} };
+    } catch (error) {
+      console.error("[VOIP SDK] endCall() failed", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to end call"
+      };
+    }
+  }
+  async toggleMute(input) {
+    console.log("[VOIP SDK] toggleMute() invoked", { callId: input.callId, mute: input.mute });
+    const tracked = this.calls.get(input.callId);
+    if (!tracked) {
+      return { success: false, error: "No active call to mute/unmute" };
+    }
+    try {
+      if (typeof tracked.call.mute === "function") {
+        await tracked.call.mute(input.mute);
+      } else if (typeof tracked.call.isMuted === "function") {
+        const current = tracked.call.isMuted();
+        if (current !== input.mute) {
+          await tracked.call.mute(input.mute);
+        }
+      }
+      console.log("[VOIP SDK] toggleMute() success", { callId: input.callId, mute: input.mute });
+      return { success: true, data: {} };
+    } catch (error) {
+      console.error("[VOIP SDK] toggleMute() failed", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to toggle mute"
+      };
+    }
+  }
+  async holdCall(input) {
+    return this.postCallControl(input.callId, "outgoingCall.hold", {
+      waitUrl: this.sdkConfig?.waitUrl ?? "https://api.twilio.com/cowbell.mp3"
+    });
+  }
+  async resumeCall(input) {
+    return this.postCallControl(input.callId, "outgoingCall.unhold");
+  }
+  /**
+   * Hold the active call then dial `newParticipantNo` into the same conference.
+   *
+   * Web SDK parity:
+   *   OUTBOUND active call → holdAndAddParticipant()
+   *     step 1: outgoingCall.hold      (same as hold())
+   *     step 2: outgoingCall.addNewCallee   { conferenceName, newParticipantNo }
+   *
+   *   INBOUND active call → holdAndAddParticipantIncoming()
+   *     step 1: outgoingCall.hold      (same as hold())
+   *     step 2: outgoingCall.addNewCalleeIncoming  { callSid, newParticipantNo }
+   */
+  async addNewCallee(input) {
+    if (!this.sdkConfig) {
+      return { success: false, error: "SDK not initialized" };
+    }
+    const tracked = this.calls.get(input.callId);
+    if (!tracked) {
+      return { success: false, error: "Active call not found" };
+    }
+    if (!input.newParticipantNo) {
+      return { success: false, error: "Participant number is required" };
+    }
+    try {
+      const holdResult = await this.postCallControl(
+        input.callId,
+        "outgoingCall.hold",
+        {
+          waitUrl: this.sdkConfig.waitUrl ?? "https://api.twilio.com/cowbell.mp3"
+        }
+      );
+      if (!holdResult.success) {
+        return { success: false, error: holdResult.error ?? "Failed to hold call before adding participant" };
+      }
+      const callSid = tracked.callSid ?? input.callId;
+      const conferenceName = tracked.conferenceName ?? this.defaultConferenceName;
+      let payload;
+      let endpoint;
+      if (tracked.direction === "INBOUND") {
+        endpoint = "outgoingCall.addNewCalleeIncoming";
+        payload = { callSid, newParticipantNo: input.newParticipantNo };
+      } else {
+        endpoint = "outgoingCall.addNewCallee";
+        payload = { conferenceName, newParticipantNo: input.newParticipantNo };
+      }
+      console.log("[VOIP SDK] addNewCallee() start", {
+        callId: input.callId,
+        direction: tracked.direction,
+        endpoint,
+        newParticipantNo: input.newParticipantNo
+      });
+      await this.axiosInstance.post(
+        `${this.sdkConfig.serverUrl}/${endpoint}`,
+        payload,
+        { headers: { Authorization: `Bearer ${this.sdkConfig.sdkToken}` } }
+      );
+      this.emit("onParticipantJoined", { callId: input.callId, number: input.newParticipantNo });
+      console.log("[VOIP SDK] addNewCallee() success", { callId: input.callId, endpoint });
+      return { success: true, data: {} };
+    } catch (error) {
+      console.error("[VOIP SDK] addNewCallee() failed", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to add participant"
+      };
+    }
+  }
+  async mergeCall(input) {
+    const control = await this.postCallControl(input.callId, "outgoingCall.unhold");
+    if (!control.success) {
+      return {
+        success: false,
+        error: control.error ?? "Failed to merge call"
+      };
+    }
+    const existing = this.calls.get(input.callId);
+    const session = {
+      callId: input.callId,
+      direction: existing?.direction ?? "OUTBOUND",
+      status: "MERGED",
+      participants: [],
+      conferenceRoomId: null
+    };
+    return { success: true, data: session };
+  }
+  async getParticipants(input) {
+    if (!this.sdkConfig) {
+      return { success: false, error: "SDK not initialized" };
+    }
+    try {
+      const tracked = this.calls.get(input.callId);
+      const conferenceSid = tracked?.conferenceName ?? input.callId;
+      const res = await this.axiosInstance.post(
+        `${this.sdkConfig.serverUrl}/outgoingCall.getParticipants`,
+        { conferenceSid },
+        {
+          headers: {
+            Authorization: `Bearer ${this.sdkConfig.sdkToken}`
+          }
+        }
+      );
+      const participants = res?.data?.result?.data?.participants ?? [];
+      return { success: true, data: participants };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to fetch participants"
+      };
+    }
+  }
+  async getConferenceId(input) {
+    if (!this.sdkConfig) {
+      return { success: false, error: "SDK not initialized" };
+    }
+    console.log("[VOIP SDK] getConferenceId() invoked", { conferenceName: input.conferenceName });
+    try {
+      const res = await this.axiosInstance.post(
+        `${this.sdkConfig.serverUrl}/outgoingCall.getConferenceId`,
+        { conferenceName: input.conferenceName },
+        { headers: { Authorization: `Bearer ${this.sdkConfig.sdkToken}` } }
+      );
+      const conferenceDetail = res?.data?.result?.data ?? null;
+      console.log("[VOIP SDK] getConferenceId() success", { conferenceDetail });
+      return { success: true, data: conferenceDetail };
+    } catch (error) {
+      console.error("[VOIP SDK] getConferenceId() failed", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to fetch conference ID"
+      };
+    }
+  }
+  async getParticipantsByCallSid(input) {
+    if (!this.sdkConfig) {
+      return { success: false, error: "SDK not initialized" };
+    }
+    console.log("[VOIP SDK] getParticipantsByCallSid() invoked", { callSid: input.callSid });
+    try {
+      const res = await this.axiosInstance.post(
+        `${this.sdkConfig.serverUrl}/outgoingCall.getConferenceCallsByConferenceId`,
+        { callSid: input.callSid },
+        { headers: { Authorization: `Bearer ${this.sdkConfig.sdkToken}` } }
+      );
+      const participants = res?.data?.result?.data ?? [];
+      console.log("[VOIP SDK] getParticipantsByCallSid() success", { count: participants.length });
+      return { success: true, data: participants };
+    } catch (error) {
+      console.error("[VOIP SDK] getParticipantsByCallSid() failed", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to fetch participants"
+      };
+    }
+  }
+  async removeParticipant(input) {
+    if (!this.sdkConfig) {
+      return { success: false, error: "SDK not initialized" };
+    }
+    console.log("[VOIP SDK] removeParticipant() invoked", {
+      conferenceSid: input.conferenceSid,
+      callSid: input.callSid
+    });
+    try {
+      await this.axiosInstance.post(
+        `${this.sdkConfig.serverUrl}/outgoingCall.removeParticipant`,
+        {
+          conferenceSid: input.conferenceSid,
+          callSid: input.callSid
+        },
+        { headers: { Authorization: `Bearer ${this.sdkConfig.sdkToken}` } }
+      );
+      this.emit("onParticipantLeft", { participantId: input.callSid });
+      console.log("[VOIP SDK] removeParticipant() success");
+      return { success: true, data: {} };
+    } catch (error) {
+      console.error("[VOIP SDK] removeParticipant() failed", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to remove participant"
+      };
+    }
+  }
+  async disconnectParticipant(input) {
+    if (!this.sdkConfig) {
+      return { success: false, error: "SDK not initialized" };
+    }
+    try {
+      await this.axiosInstance.post(
+        `${this.sdkConfig.serverUrl}/outgoingCall.removeParticipant`,
+        {
+          conferenceSid: this.defaultConferenceName,
+          callSid: input.participantId
+        },
+        {
+          headers: {
+            Authorization: `Bearer ${this.sdkConfig.sdkToken}`
+          }
+        }
+      );
+      this.emit("onParticipantLeft", { participantId: input.participantId });
+      return { success: true, data: {} };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to disconnect participant"
+      };
+    }
+  }
+  addListener(eventName, callback) {
+    const set = this.listeners.get(eventName) ?? /* @__PURE__ */ new Set();
+    set.add(callback);
+    this.listeners.set(eventName, set);
+    return {
+      remove: () => {
+        const active = this.listeners.get(eventName);
+        if (!active) return;
+        active.delete(callback);
+        if (active.size === 0) {
+          this.listeners.delete(eventName);
+        }
+      }
+    };
+  }
+  emit(eventName, payload) {
+    const set = this.listeners.get(eventName);
+    if (!set) return;
+    set.forEach((listener) => listener(payload));
+  }
+  bindVoiceEvents() {
+    this.voice.on(Voice.Event.CallInvite, (invite) => {
+      const callId = this.readInviteSid(invite) ?? `incoming_${Date.now()}`;
+      const from = (typeof invite.getFrom === "function" ? invite.getFrom() : null) ?? "Unknown";
+      const to = (typeof invite.getTo === "function" ? invite.getTo() : null) ?? "";
+      console.log("[VOIP SDK] received call event", { callId, from, to });
+      this.callInvites.set(callId, invite);
+      this.emit("onCallRinging", { callId, direction: "INBOUND", from, to });
+      invite.on("cancelled", () => {
+        this.callInvites.delete(callId);
+        this.emit("onMissedCall", { callId });
+        this.emit("onCallEnded", { callId, reason: "cancelled" });
+      });
+    });
+    if (typeof this.voice.on === "function") {
+      this.voice.on(Voice.Event.Registered, () => {
+        console.log("[VOIP SDK] Device registered (onReady)");
+        this.emit("onReady", {});
+      });
+    }
+    this.voice.on(Voice.Event.Error, (error) => {
+      console.error("[VOIP DEBUG] websocket state", {
+        state: "ERROR",
+        message: error?.message ?? String(error)
+      });
+      this.emit("onError", {
+        scope: "voice",
+        message: error?.message ?? String(error)
+      });
+    });
+  }
+  bindCallEvents(callId, call) {
+    call.on("ringing", () => {
+      console.log("[VOIP DEBUG] call ringing", { callId });
+      this.emit("onCallStateChanged", { callId, status: "RINGING" });
+    });
+    call.on("connected", () => {
+      console.log("[VOIP DEBUG] media stream started", { callId });
+      const tracked = this.calls.get(callId);
+      let liveSid = null;
+      if (tracked) {
+        liveSid = this.readCallSid(call);
+        if (liveSid) {
+          tracked.callSid = liveSid;
+          this.calls.set(callId, tracked);
+          console.log("[VOIP DEBUG] callSid captured on connect", { callId, callSid: liveSid });
+        }
+        this.fetchConferenceId(callId, tracked.conferenceName ?? this.defaultConferenceName).catch(
+          (err) => console.warn("[VOIP SDK] getConferenceId failed after connect", err)
+        );
+      }
+      this.emit("onCallConnected", { callId, callSid: liveSid ?? callId, status: "CONNECTED" });
+      this.emit("onCallStateChanged", { callId, callSid: liveSid ?? callId, status: "CONNECTED" });
+    });
+    call.on("reconnecting", () => {
+      console.log("[VOIP DEBUG] reconnect attempt", { callId });
+      this.emit("onCallStateChanged", { callId, status: "RECONNECTING" });
+    });
+    call.on("disconnected", (error) => {
+      this.calls.delete(callId);
+      this.emit("onCallEnded", {
+        callId,
+        reason: error?.message ?? null
+      });
+      console.log("[VOIP DEBUG] call ended", {
+        callId,
+        reason: error?.message ?? null
+      });
+    });
+    call.on("connectFailure", (error) => {
+      const reason = error?.message ?? String(error);
+      console.error("[VOIP DEBUG] call connect failure", { callId, message: reason });
+      this.calls.delete(callId);
+      this.emit("onCallEnded", { callId, reason });
+      this.emit("onError", {
+        scope: "call_connect",
+        callId,
+        message: reason
+      });
+    });
+  }
+  async fetchConferenceId(callId, conferenceName) {
+    if (!this.sdkConfig) return;
+    console.log("[VOIP SDK] fetchConferenceId() start", { callId, conferenceName });
+    try {
+      const res = await this.axiosInstance.post(
+        `${this.sdkConfig.serverUrl}/outgoingCall.getConferenceId`,
+        { conferenceName },
+        { headers: { Authorization: `Bearer ${this.sdkConfig.sdkToken}` } }
+      );
+      const conferenceDetail = res?.data?.result?.data ?? null;
+      const tracked = this.calls.get(callId);
+      if (tracked && conferenceDetail) {
+        tracked.conferenceDetail = conferenceDetail;
+        this.calls.set(callId, tracked);
+        console.log("[VOIP SDK] conference detail stored", { callId, conferenceDetail });
+      }
+      this.emit("onCallStateChanged", {
+        callId,
+        status: "CONNECTED",
+        conferenceDetail
+      });
+    } catch (err) {
+      console.warn("[VOIP SDK] fetchConferenceId() failed", err);
+    }
+  }
+  readCallSid(call) {
+    if (!call) return null;
+    if (typeof call.getSid === "function") {
+      const sid = call.getSid();
+      return typeof sid === "string" ? sid : null;
+    }
+    return null;
+  }
+  readInviteSid(invite) {
+    if (!invite) return null;
+    if (typeof invite.getCallSid === "function") {
+      const sid = invite.getCallSid();
+      return typeof sid === "string" ? sid : null;
+    }
+    return null;
+  }
+  async postCallControl(callId, endpoint, extraPayload) {
+    console.log("[VOIP SDK] postCallControl() start", { callId, endpoint });
+    if (!this.sdkConfig) {
+      return { success: false, error: "SDK not initialized" };
+    }
+    const tracked = this.calls.get(callId);
+    const callSid = tracked?.callSid ?? callId;
+    const conferenceName = tracked?.conferenceName ?? this.defaultConferenceName;
+    try {
+      await this.axiosInstance.post(
+        `${this.sdkConfig.serverUrl}/${endpoint}`,
+        {
+          callSid,
+          conferenceName,
+          ...extraPayload ?? {}
+        },
+        {
+          headers: {
+            Authorization: `Bearer ${this.sdkConfig.sdkToken}`
+          }
+        }
+      );
+      console.log("[VOIP SDK] postCallControl() success", { callId, endpoint });
+      return { success: true, data: {} };
+    } catch (error) {
+      console.error("[VOIP SDK] postCallControl() failed", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Call control failed"
+      };
+    }
+  }
+  captureAccessToken(payload) {
+    if (!payload) return;
+    console.log("[VOIP DEBUG] captureAccessToken() invoked");
+    if (typeof payload.accessToken === "string" && payload.accessToken.trim()) {
+      this.runtimeAccessToken = payload.accessToken.trim();
+      return;
+    }
+    const tokenFromMetadata = payload.metadata?.accessToken;
+    if (typeof tokenFromMetadata === "string" && tokenFromMetadata.trim().length > 0) {
+      this.runtimeAccessToken = tokenFromMetadata.trim();
+    }
+  }
+  async generateVoiceAccessToken() {
+    if (!this.sdkConfig) {
+      throw new Error("SDK not initialized");
+    }
+    const payload = {
+      identity: this.sdkConfig.identity,
+      ttl: 3600,
+      incomingAllow: true
+    };
+    console.log("[VOIP DEBUG] token generation start");
+    const res = await this.axiosInstance.post(
+      `${this.sdkConfig.serverUrl}/voipSdk.generateToken`,
+      payload,
+      {
+        headers: {
+          Authorization: `Bearer ${this.sdkConfig.sdkToken}`
+        }
+      }
+    );
+    const token = res?.data?.result?.data?.token ?? res?.data?.result?.token ?? res?.data?.token;
+    if (typeof token !== "string" || token.trim().length === 0) {
+      throw new Error("Token generation failed: empty access token");
+    }
+    console.log("[VOIP DEBUG] token generation success");
+    return token.trim();
+  }
+  async registerVoiceClient(token) {
+    if (!this.isVoiceNativeModuleAvailable()) {
+      throw new Error(
+        "Twilio native module not available (TwilioVoiceReactNative). Rebuild app after installing @twilio/voice-react-native-sdk."
+      );
+    }
+    try {
+      const shouldRegisterOnAndroid = Platform.OS !== "android" || Boolean(
+        this.sdkConfig?.enableAndroidVoiceRegister
+      );
+      if (!shouldRegisterOnAndroid) {
+        console.warn(
+          "[VOIP SDK] Android voice.register() skipped to prevent crash. Enable `enableAndroidVoiceRegister` only after Firebase + Twilio incoming-call push setup."
+        );
+        this.isVoiceRegistered = false;
+        return;
+      }
+      if (Platform.OS === "ios") {
+        await this.voice.initializePushRegistry();
+      }
+      await this.voice.register(token);
+      this.isVoiceRegistered = true;
+      console.log("[VOIP SDK] websocket connected");
+    } catch (error) {
+      this.isVoiceRegistered = false;
+      throw error;
+    }
+  }
+  isVoiceNativeModuleAvailable() {
+    return Boolean(NativeModules?.TwilioVoiceReactNative);
+  }
+  getVoiceAccessToken() {
+    if (this.runtimeAccessToken && this.runtimeAccessToken.trim()) {
+      return this.runtimeAccessToken.trim();
+    }
+    if (this.sdkConfig?.accessToken && this.sdkConfig.accessToken.trim()) {
+      return this.sdkConfig.accessToken.trim();
+    }
+    return null;
+  }
+};
+
+// src/react-native-voip-sdk/bridge/native-module.ts
+var defaultNativeModule = new TwilioVoiceAdapter();
+function resolveNativeModule(custom) {
+  if (custom) return custom;
+  return defaultNativeModule;
+}
+
+// src/react-native-voip-sdk/bridge/index.ts
+var BridgeClient = class {
+  constructor(nativeModule) {
+    this.events = new BridgeEventEmitter();
+    this.nativeSubscriptions = [];
+    this.nativeModule = resolveNativeModule(nativeModule);
+    console.log("[VOIP SDK] BridgeClient initialized");
+    this.subscribeToNativeEvents();
+  }
+  on(eventName, listener) {
+    return this.events.on(eventName, listener);
+  }
+  emit(eventName, payload) {
+    console.log("[VOIP EVENT] bridge emit", { eventName, payload });
+    this.events.emit(eventName, payload);
+  }
+  destroy() {
+    this.nativeSubscriptions.forEach((sub) => sub.remove());
+    this.nativeSubscriptions = [];
+    this.events.removeAllListeners();
+  }
+  subscribeToNativeEvents() {
+    if (!this.nativeModule.addListener) return;
+    const sdkEvents = [
+      "onReady",
+      "onCallRinging",
+      "onCallConnected",
+      "onParticipantJoined",
+      "onParticipantLeft",
+      "onCallEnded",
+      "onCallStateChanged",
+      "onAuthStateChanged",
+      "onMissedCall",
+      "onError"
+    ];
+    sdkEvents.forEach((eventName) => {
+      const sub = this.nativeModule.addListener?.(eventName, (payload) => {
+        console.log("[VOIP EVENT] native event", { eventName, payload });
+        this.events.emit(eventName, payload);
+      });
+      if (sub) {
+        this.nativeSubscriptions.push(sub);
+      }
+    });
+  }
+};
+
+// src/react-native-voip-sdk/core/auth/authManager.ts
+var AuthManager = class {
+  constructor(transport, retry, emit) {
+    this.transport = transport;
+    this.retry = retry;
+    this.emit = emit;
+    this.authState = "UNAUTHENTICATED";
+    this.auth = null;
+    this.refreshTimer = null;
+  }
+  getState() {
+    return this.authState;
+  }
+  getAuth() {
+    return this.auth;
+  }
+  async authenticate(payload) {
+    console.log("[VOIP SDK] auth started");
+    console.log("[VOIP DEBUG] token validation", {
+      hasAccessToken: Boolean(payload?.accessToken)
+    });
+    this.setState("AUTHENTICATING");
+    const result = await this.retry.execute(
+      async () => this.transport.authenticate(payload),
+      { operation: "token_exchange" }
+    );
+    if (!result.success || !result.data) {
+      this.setState("UNAUTHENTICATED");
+      console.error("[VOIP SDK] auth failed", {
+        message: result.error ?? "Authentication failed"
+      });
+      throw new Error(result.error ?? "Authentication failed");
+    }
+    this.auth = result.data;
+    this.setState("AUTHENTICATED");
+    this.scheduleRefresh();
+    console.log("[VOIP SDK] auth success", {
+      consumerId: result.data.consumerId,
+      expiresAt: result.data.expiresAt
+    });
+    return result.data;
+  }
+  async refreshIfNeeded() {
+    console.log("[VOIP DEBUG] refreshIfNeeded() start");
+    if (!this.auth) {
+      this.setState("EXPIRED");
+      throw new Error("No auth session to refresh");
+    }
+    if (!this.transport.refreshAuth) return;
+    this.setState("REFRESHING");
+    const result = await this.retry.execute(
+      async () => this.transport.refreshAuth?.() ?? { success: false, error: "refresh not supported" },
+      { operation: "token_refresh" }
+    );
+    const data = result.success ? result.data : void 0;
+    const error = !result.success ? result.error : void 0;
+    if (!result.success || !data) {
+      this.auth = null;
+      this.setState("EXPIRED");
+      console.error("[VOIP DEBUG] token refresh failed", {
+        message: error ?? "Token refresh failed"
+      });
+      throw new Error(error ?? "Token refresh failed");
+    }
+    this.auth = data;
+    this.setState("AUTHENTICATED");
+    this.scheduleRefresh();
+    console.log("[VOIP DEBUG] token refresh success");
+  }
+  destroy() {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    this.auth = null;
+    this.setState("UNAUTHENTICATED");
+  }
+  setState(nextState) {
+    this.authState = nextState;
+    this.emit("onAuthStateChanged", { state: nextState });
+  }
+  scheduleRefresh() {
+    if (!this.auth?.expiresAt) return;
+    if (this.refreshTimer) clearTimeout(this.refreshTimer);
+    const now = Date.now();
+    const refreshAt = Math.max(now, this.auth.expiresAt - 2 * 60 * 1e3);
+    const delay = Math.max(1e3, refreshAt - now);
+    this.refreshTimer = setTimeout(() => {
+      void this.refreshIfNeeded().catch((error) => {
+        this.emit("onError", {
+          scope: "auth",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }, delay);
+  }
+};
+
+// src/react-native-voip-sdk/core/call-engine/callEngine.ts
+var CallEngine = class {
+  constructor(nativeModule, retry, emit) {
+    this.nativeModule = nativeModule;
+    this.retry = retry;
+    this.emit = emit;
+    this.sessions = /* @__PURE__ */ new Map();
+  }
+  getSession(callId) {
+    return this.sessions.get(callId);
+  }
+  async startCall(number) {
+    console.log("[VOIP SDK] startCall() invoked", { number });
+    const callId = `call_${Date.now()}_${Math.floor(Math.random() * 1e3)}`;
+    const result = await this.retry.execute(
+      async () => this.nativeModule.startCall({ number, callId }),
+      { operation: "call_setup" }
+    );
+    if (!result.success || !result.data) {
+      console.error("[VOIP SDK] call request failed", {
+        message: result.error ?? "Failed to start call"
+      });
+      throw new Error(result.error ?? "Failed to start call");
+    }
+    console.log("[VOIP DEBUG] dial request success", {
+      callId: result.data.callId
+    });
+    this.sessions.set(result.data.callId, result.data);
+    this.emit("onCallStateChanged", {
+      callId: result.data.callId,
+      status: result.data.status,
+      direction: result.data.direction
+    });
+    return result.data;
+  }
+  async answerCall(callId) {
+    await this.execCallCommand("answerCall", callId, "ANSWERED");
+  }
+  async endCall(callId) {
+    console.log("[VOIP SDK] endCall() invoked", { callId });
+    await this.execCallCommand("endCall", callId, "ENDED");
+    console.log("[VOIP DEBUG] call ended", { callId });
+    this.emit("onCallEnded", { callId });
+  }
+  async holdCall(callId) {
+    await this.execCallCommand("holdCall", callId, "ON_HOLD");
+  }
+  async resumeCall(callId) {
+    await this.execCallCommand("resumeCall", callId, "RESUMED");
+  }
+  async toggleMute(callId, mute) {
+    console.log("[VOIP SDK] toggleMute() invoked", { callId, mute });
+    if (!this.nativeModule.toggleMute) {
+      throw new Error("toggleMute not supported by native module");
+    }
+    const result = await this.retry.execute(
+      async () => this.nativeModule.toggleMute({ callId, mute }),
+      { operation: "call_control_toggleMute" }
+    );
+    if (!result.success) {
+      throw new Error(result.error ?? "Failed to toggle mute");
+    }
+    this.emit("onCallStateChanged", { callId, muted: mute });
+    console.log("[VOIP SDK] toggleMute() success", { callId, mute });
+  }
+  async mergeCall(callId) {
+    const result = await this.retry.execute(
+      async () => this.nativeModule.mergeCall({ callId }),
+      { operation: "merge_call" }
+    );
+    if (!result.success || !result.data) {
+      throw new Error(result.error ?? "Failed to merge call");
+    }
+    this.sessions.set(result.data.callId, result.data);
+    this.emit("onCallStateChanged", {
+      callId: result.data.callId,
+      status: result.data.status,
+      direction: result.data.direction
+    });
+    return result.data;
+  }
+  async execCallCommand(methodName, callId, status) {
+    console.log("[VOIP SDK] call control start", { methodName, callId, status });
+    const result = await this.retry.execute(
+      async () => this.nativeModule[methodName]({ callId }),
+      { operation: `call_control_${methodName}` }
+    );
+    if (!result.success) {
+      console.error("[VOIP SDK] call control failure", {
+        methodName,
+        callId,
+        message: result.error ?? `Failed ${methodName}`
+      });
+      throw new Error(result.error ?? `Failed ${methodName}`);
+    }
+    const existing = this.sessions.get(callId);
+    if (existing) {
+      existing.status = status;
+      this.sessions.set(callId, existing);
+    }
+    this.emit("onCallStateChanged", { callId, status });
+    console.log("[VOIP SDK] call control success", { methodName, callId, status });
+  }
+};
+
+// src/react-native-voip-sdk/core/config/configService.ts
+import axios2 from "axios";
+
+// src/parseRules.ts
+async function createParseRule(deps, input) {
+  deps.ensureAuthenticated();
+  try {
+    const res = await deps.axiosInstance.post(
+      `${deps.serverUrl}/voipSdk.createParseRule`,
+      input,
+      {
+        headers: {
+          Authorization: `Bearer ${deps.sdkToken}`
+        }
+      }
+    );
+    const data = res?.data?.result ?? res?.data ?? null;
+    if (!data) {
+      throw new Error("Invalid response from server");
+    }
+    return createSuccessResult(
+      "Parse rule configuration created successfully",
+      data
+    );
+  } catch (error) {
+    return createErrorResult(
+      error instanceof Error ? error.message : "Failed to create parse rule configuration"
+    );
+  }
+}
+async function listParseRules(deps, input) {
+  deps.ensureAuthenticated();
+  try {
+    const res = await deps.axiosInstance.post(
+      `${deps.serverUrl}/voipSdk.listParseRules`,
+      input ?? {},
+      {
+        headers: {
+          Authorization: `Bearer ${deps.sdkToken}`
+        }
+      }
+    );
+    const data = res?.data?.result ?? res?.data ?? null;
+    if (!data) {
+      throw new Error("Invalid response from server");
+    }
+    return createSuccessResult(
+      "Parse rules fetched successfully",
+      data
+    );
+  } catch (error) {
+    return createErrorResult(
+      error instanceof Error ? error.message : "Failed to list parse rules"
+    );
+  }
+}
+
+// src/routingConfig.ts
+async function getRoutingConfig(deps) {
+  deps.ensureAuthenticated();
+  try {
+    const res = await deps.axiosInstance.get(
+      `${deps.serverUrl}/voipSdk.getRoutingConfig`,
+      {
+        headers: {
+          Authorization: `Bearer ${deps.sdkToken}`
+        }
+      }
+    );
+    const data = res?.data?.result ?? res?.data ?? null;
+    if (!data) {
+      throw new Error("Invalid response from server");
+    }
+    return createSuccessResult(
+      "Routing configuration fetched successfully",
+      data
+    );
+  } catch (error) {
+    return createErrorResult(
+      error instanceof Error ? error.message : "Failed to fetch routing configuration"
+    );
+  }
+}
+async function setRoutingConfig(deps, input) {
+  deps.ensureAuthenticated();
+  try {
+    const res = await deps.axiosInstance.post(
+      `${deps.serverUrl}/voipSdk.setRoutingConfig`,
+      input,
+      {
+        headers: {
+          Authorization: `Bearer ${deps.sdkToken}`
+        }
+      }
+    );
+    const data = res?.data?.result ?? res?.data ?? null;
+    if (!data) {
+      throw new Error("Invalid response from server");
+    }
+    return createSuccessResult(
+      data.message || "Routing configuration updated successfully",
+      data
+    );
+  } catch (error) {
+    return createErrorResult(
+      error instanceof Error ? error.message : "Failed to update routing configuration"
+    );
+  }
+}
+
+// src/webhook.ts
+function validateWebhookUrl(webhookUrl) {
+  const trimmed = (webhookUrl ?? "").trim();
+  if (!trimmed) throw new Error("Webhook URL is required");
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new Error("Invalid webhook URL");
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw new Error("Webhook URL must start with http:// or https://");
+  }
+  return parsed.toString();
+}
+async function registerWebhook(deps, webhookUrl) {
+  deps.ensureAuthenticated();
+  try {
+    const normalizedUrl = validateWebhookUrl(webhookUrl);
+    const payload = { webhookUrl: normalizedUrl };
+    await deps.axiosInstance.post(
+      `${deps.serverUrl}/voipSdk.registerWebhook`,
+      payload,
+      { headers: { Authorization: `Bearer ${deps.sdkToken}` } }
+    );
+    return createSuccessResult("Webhook registered", { webhookUrl: normalizedUrl });
+  } catch (error) {
+    return createErrorResult(
+      error instanceof Error ? error : "Webhook registration failed"
+    );
+  }
+}
+async function deregisterWebhook(deps) {
+  deps.ensureAuthenticated();
+  try {
+    const payload = {};
+    await deps.axiosInstance.post(
+      `${deps.serverUrl}/voipSdk.deRegisterWebHook`,
+      payload,
+      { headers: { Authorization: `Bearer ${deps.sdkToken}` } }
+    );
+    return createSuccessResult("Webhook deregistered", null);
+  } catch (error) {
+    return createErrorResult(
+      error instanceof Error ? error : "Webhook deregistration failed"
+    );
+  }
+}
+async function isWebhookConfigured(deps) {
+  deps.ensureAuthenticated();
+  try {
+    const res = await deps.axiosInstance.get(
+      `${deps.serverUrl}/voipSdk.isConfiguredWebhookUrl`,
+      { headers: { Authorization: `Bearer ${deps.sdkToken}` } }
+    );
+    const data = res?.data?.result?.data ?? res?.data?.data ?? null;
+    const rawUrl = data?.webhookUrl ?? data?.url ?? (typeof data === "string" ? data : void 0);
+    const url = rawUrl ? String(rawUrl) : null;
+    const configured = Boolean(url);
+    const result = { configured, webhookUrl: url };
+    return createSuccessResult("Webhook configuration fetched", result);
+  } catch (error) {
+    return createErrorResult(
+      error instanceof Error ? error : "Webhook configuration check failed"
+    );
+  }
+}
+
+// src/welcomeMessageConfig.ts
+function isUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function isAudioLikeInput(value) {
+  return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("data:audio/");
+}
+function validateWelcomeConfigInput(input) {
+  const welcomeMessage = input.welcomeMessage?.trim();
+  if (!welcomeMessage) {
+    throw new Error("Payload is missing or empty. welcomeMessage is required.");
+  }
+  if (input.welcomeType === "tts") {
+    if (isAudioLikeInput(welcomeMessage)) {
+      throw new Error(
+        "welcomeType is tts but input appears to be audio. Only text is allowed for TTS."
+      );
+    }
+  }
+  if (input.welcomeType === "audio") {
+    if (!isUrl(welcomeMessage)) {
+      throw new Error(
+        "welcomeType is audio but welcomeMessage must be a valid URL (e.g. S3 URL)."
+      );
+    }
+  }
+  return {
+    welcomeType: input.welcomeType,
+    welcomeMessage
+  };
+}
+async function welcomeMessageConfig(deps, input) {
+  deps.ensureAuthenticated();
+  try {
+    const payload = validateWelcomeConfigInput(input);
+    const res = await deps.axiosInstance.post(
+      `${deps.serverUrl}/voipSdk.welcomeMessageConfig`,
+      payload,
+      {
+        headers: {
+          Authorization: `Bearer ${deps.sdkToken}`
+        }
+      }
+    );
+    const data = res?.data?.result ?? res?.data ?? null;
+    if (!data) {
+      throw new Error("Invalid response from server");
+    }
+    return createSuccessResult(
+      data.message || "Welcome configuration updated successfully",
+      {
+        success: data.success,
+        message: data.message,
+        welcomeType: data.welcomeType,
+        routingConfigId: data.routingConfigId
+      }
+    );
+  } catch (error) {
+    return createErrorResult(
+      error instanceof Error ? error : "Failed to upsert welcome configuration"
+    );
+  }
+}
+
+// src/react-native-voip-sdk/core/config/configService.ts
+var ConfigService = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.axiosInstance = axios2.create();
+    this.axiosInstance.defaults.baseURL = deps.serverUrl;
+  }
+  setAccessToken(token) {
+    this.axiosInstance.defaults.headers.common.Authorization = `Bearer ${token}`;
+  }
+  async getRoutingConfig() {
+    return getRoutingConfig(this.withDeps());
+  }
+  async setRoutingConfig(input) {
+    return setRoutingConfig(this.withDeps(), input);
+  }
+  async createParseRule(input) {
+    return createParseRule(this.withDeps(), input);
+  }
+  async listParseRules(input) {
+    return listParseRules(this.withDeps(), input);
+  }
+  async registerWebhook(webhookUrl) {
+    return registerWebhook(this.withDeps(), webhookUrl);
+  }
+  async deregisterWebhook() {
+    return deregisterWebhook(this.withDeps());
+  }
+  async isWebhookConfigured() {
+    return isWebhookConfigured(this.withDeps());
+  }
+  async welcomeMessageConfig(welcomeType, welcomeMessage) {
+    return welcomeMessageConfig(this.withDeps(), { welcomeType, welcomeMessage });
+  }
+  withDeps() {
+    return {
+      axiosInstance: this.axiosInstance,
+      serverUrl: this.deps.serverUrl,
+      sdkToken: this.deps.sdkToken,
+      ensureAuthenticated: this.deps.ensureAuthenticated
+    };
+  }
+};
+
+// src/react-native-voip-sdk/core/conference/conferenceManager.ts
+var ConferenceManager = class {
+  constructor(nativeModule, retry, emit) {
+    this.nativeModule = nativeModule;
+    this.retry = retry;
+    this.emit = emit;
+  }
+  async getParticipants(callId) {
+    const result = await this.retry.execute(
+      async () => this.nativeModule.getParticipants({ callId }),
+      { operation: "participant_fetch" }
+    );
+    if (!result.success || !result.data) {
+      throw new Error(result.error ?? "Failed to fetch participants");
+    }
+    return result.data;
+  }
+  async disconnectParticipant(participantId) {
+    const result = await this.retry.execute(
+      async () => this.nativeModule.disconnectParticipant({ participantId }),
+      { operation: "participant_disconnect" }
+    );
+    if (!result.success) {
+      throw new Error(result.error ?? "Failed to disconnect participant");
+    }
+    this.emit("onParticipantLeft", { participantId });
+  }
+};
+
+// src/react-native-voip-sdk/core/retry/retryPolicy.ts
+var DEFAULT_RETRY_POLICY = {
+  maxRetries: 4,
+  baseDelayMs: 400,
+  maxDelayMs: 8e3,
+  jitterRatio: 0.25,
+  circuitBreakerThreshold: 5,
+  circuitBreakerCooldownMs: 15e3
+};
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var CircuitBreaker = class {
+  constructor(threshold, cooldownMs) {
+    this.threshold = threshold;
+    this.cooldownMs = cooldownMs;
+    this.failureCount = 0;
+    this.openedAt = 0;
+  }
+  canExecute() {
+    if (this.failureCount < this.threshold) return true;
+    if (Date.now() - this.openedAt > this.cooldownMs) {
+      this.failureCount = 0;
+      this.openedAt = 0;
+      return true;
+    }
+    return false;
+  }
+  recordSuccess() {
+    this.failureCount = 0;
+    this.openedAt = 0;
+  }
+  recordFailure() {
+    this.failureCount += 1;
+    if (this.failureCount >= this.threshold && this.openedAt === 0) {
+      this.openedAt = Date.now();
+    }
+  }
+};
+var RetryPolicy = class {
+  constructor(config) {
+    this.config = { ...DEFAULT_RETRY_POLICY, ...config };
+    this.breaker = new CircuitBreaker(
+      this.config.circuitBreakerThreshold,
+      this.config.circuitBreakerCooldownMs
+    );
+  }
+  async execute(task, context) {
+    console.log("[VOIP DEBUG] retry.execute() start", {
+      operation: context.operation,
+      maxRetries: this.config.maxRetries
+    });
+    if (!this.breaker.canExecute()) {
+      console.error("[VOIP DEBUG] circuit breaker open", {
+        operation: context.operation
+      });
+      throw new Error(`Circuit open for operation: ${context.operation}`);
+    }
+    let attempt = 0;
+    let lastError;
+    while (attempt <= this.config.maxRetries) {
+      try {
+        if (attempt > 0) {
+          console.log("[VOIP DEBUG] reconnect attempt", {
+            operation: context.operation,
+            retryCount: attempt
+          });
+        }
+        const result = await task();
+        this.breaker.recordSuccess();
+        console.log("[VOIP DEBUG] retry.execute() success", {
+          operation: context.operation,
+          attempt
+        });
+        return result;
+      } catch (error) {
+        lastError = error;
+        this.breaker.recordFailure();
+        console.error("[VOIP DEBUG] retry.execute() failure", {
+          operation: context.operation,
+          attempt,
+          message: error instanceof Error ? error.message : String(error)
+        });
+        if (attempt === this.config.maxRetries) break;
+        const baseDelay = Math.min(
+          this.config.baseDelayMs * 2 ** attempt,
+          this.config.maxDelayMs
+        );
+        const jitter = baseDelay * this.config.jitterRatio * (Math.random() * 2 - 1);
+        const delay = Math.max(0, Math.floor(baseDelay + jitter));
+        console.log("[VOIP DEBUG] websocket state", {
+          operation: context.operation,
+          state: "RETRY_WAIT",
+          delayMs: delay
+        });
+        await wait(delay);
+        attempt += 1;
+      }
+    }
+    console.error("[VOIP DEBUG] retry.execute() exhausted", {
+      operation: context.operation
+    });
+    throw lastError instanceof Error ? lastError : new Error(`Retry failed for operation: ${context.operation}`);
+  }
+};
+
+// src/react-native-voip-sdk/js/public-api.ts
+function logVoipDebug(message, payload) {
+  if (payload) {
+    console.log(`[VOIP SDK] ${message}`, payload);
+    return;
+  }
+  console.log(`[VOIP SDK] ${message}`);
+}
+var ReactNativeVoipSdk = class {
+  constructor(config, nativeModule) {
+    this.initialized = false;
+    this.activeCallId = null;
+    /** Tracks every in-flight call leg (parallel or single); kept in sync with native `onCallEnded`. */
+    this.activeCallIds = /* @__PURE__ */ new Set();
+    this.unsubscribeOnCallEnded = null;
+    logVoipDebug("constructor() invoked", {
+      hasServerUrl: Boolean(config.serverUrl),
+      hasIdentity: Boolean(config.identity),
+      hasSdkToken: Boolean(config.sdkToken),
+      hasAccessToken: Boolean(config.accessToken)
+    });
+    this.internalConferenceName = `conf_${config.identity}_${Date.now()}`;
+    this.sdkConfig = {
+      serverUrl: config.serverUrl,
+      consumerId: config.identity,
+      identity: config.identity,
+      sdkToken: config.sdkToken,
+      accessToken: config.accessToken,
+      waitUrl: config.waitUrl
+    };
+    this.bridge = new BridgeClient(nativeModule);
+    this.retry = new RetryPolicy(config.retry);
+    this.authManager = new AuthManager(
+      {
+        authenticate: async (payload) => this.bridge.nativeModule.authenticate(payload),
+        refreshAuth: async () => this.bridge.nativeModule.refreshAuth?.() ?? {
+          success: false,
+          error: "Native refreshAuth not implemented"
+        }
+      },
+      this.retry,
+      (eventName, payload) => this.bridge.emit(eventName, payload)
+    );
+    this.callEngine = new CallEngine(
+      this.bridge.nativeModule,
+      this.retry,
+      (eventName, payload) => this.bridge.emit(eventName, payload)
+    );
+    this.conferenceManager = new ConferenceManager(
+      this.bridge.nativeModule,
+      this.retry,
+      (eventName, payload) => this.bridge.emit(eventName, payload)
+    );
+    this.configService = new ConfigService({
+      serverUrl: this.sdkConfig.serverUrl,
+      sdkToken: this.sdkConfig.sdkToken,
+      ensureAuthenticated: this.ensureAuthenticated.bind(this)
+    });
+    this.unsubscribeOnCallEnded = this.bridge.on("onCallEnded", (payload) => {
+      const callId = typeof payload.callId === "string" ? payload.callId : null;
+      if (!callId) return;
+      this.activeCallIds.delete(callId);
+      if (this.activeCallId === callId) {
+        this.activeCallId = this.pickNextActiveCallId();
+      }
+    });
+  }
+  on(eventName, listener) {
+    return this.bridge.on(eventName, listener);
+  }
+  async initializeSDK(config) {
+    logVoipDebug("initializeSDK() called");
+    if (this.initialized) return;
+    const mergedConfig = { ...this.sdkConfig, ...config };
+    const result = await this.bridge.nativeModule.initializeSDK(mergedConfig);
+    if (!result.success) {
+      logVoipDebug("initializeSDK() failed", {
+        error: result.error ?? "Failed to initialize native VOIP SDK"
+      });
+      throw new Error(result.error ?? "Failed to initialize native VOIP SDK");
+    }
+    this.initialized = true;
+    logVoipDebug("initializeSDK() success");
+  }
+  async authenticate(payload) {
+    logVoipDebug("authenticate() start", {
+      hasAccessToken: Boolean(payload?.accessToken)
+    });
+    const auth = await this.authManager.authenticate(payload);
+    this.configService.setAccessToken(auth.accessToken);
+    logVoipDebug("authenticate() success", {
+      consumerId: auth.consumerId,
+      expiresAt: auth.expiresAt
+    });
+    return auth;
+  }
+  async startCall(number) {
+    logVoipDebug("startCall() invoked", { number });
+    this.ensureAuthenticated();
+    const session = await this.callEngine.startCall(number);
+    this.activeCallIds.add(session.callId);
+    this.activeCallId = session.callId;
+    logVoipDebug("startCall() success", { callId: session.callId });
+    return session;
+  }
+  async answerCall(callId) {
+    this.ensureAuthenticated();
+    await this.callEngine.answerCall(callId);
+  }
+  async endCall(callId) {
+    logVoipDebug("endCall() invoked", { callId });
+    this.ensureAuthenticated();
+    await this.callEngine.endCall(callId);
+    this.activeCallIds.delete(callId);
+    if (this.activeCallId === callId) {
+      this.activeCallId = this.pickNextActiveCallId();
+    }
+    logVoipDebug("endCall() success", { callId });
+  }
+  async holdCall(callId) {
+    this.ensureAuthenticated();
+    await this.callEngine.holdCall(callId);
+  }
+  async resumeCall(callId) {
+    this.ensureAuthenticated();
+    await this.callEngine.resumeCall(callId);
+  }
+  async mergeCall(callId) {
+    this.ensureAuthenticated();
+    return this.callEngine.mergeCall(callId);
+  }
+  async getParticipants(callId) {
+    this.ensureAuthenticated();
+    return this.conferenceManager.getParticipants(callId);
+  }
+  async disconnectParticipant(participantId) {
+    this.ensureAuthenticated();
+    await this.conferenceManager.disconnectParticipant(participantId);
+  }
+  // Backward-compatible aliases
+  async init() {
+    return this.initializeSDK();
+  }
+  async verifySDKToken() {
+    try {
+      await this.authenticate();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Start a call or add to a conference.
+   * Use `makeCall(to, { parallel: true })` (or `addCall(to)`) while a call is active to open a second
+   * independent leg; failures on that leg are isolated to its `callId` in `onError` / `onCallEnded`.
+   */
+  async makeCall(to, options) {
+    logVoipDebug("makeCall() start", {
+      to,
+      hasActiveCall: Boolean(this.activeCallId),
+      parallel: Boolean(options?.parallel)
+    });
+    try {
+      const destination = to.trim();
+      if (!destination) {
+        return createErrorResult("Destination required");
+      }
+      if (!this.activeCallId) {
+        const data = await this.startCall(destination);
+        logVoipDebug("makeCall() new call started", { callId: data.callId });
+        return createSuccessResult("Call started", data);
+      }
+      if (options?.parallel) {
+        const data = await this.startCall(destination);
+        logVoipDebug("makeCall() parallel call started", { callId: data.callId });
+        return createSuccessResult("Parallel call started", data);
+      }
+      if (!this.bridge.nativeModule.addNewCallee) {
+        return createErrorResult("addNewCallee not supported by native module");
+      }
+      const result = await this.bridge.nativeModule.addNewCallee({
+        callId: this.activeCallId,
+        newParticipantNo: destination
+      });
+      if (!result.success) {
+        logVoipDebug("makeCall() addNewCallee failed", { error: result.error });
+        return createErrorResult(result.error ?? "Failed to add participant");
+      }
+      const existingSession = this.callEngine.getSession(this.activeCallId);
+      const session = existingSession ?? {
+        callId: this.activeCallId,
+        direction: "OUTBOUND",
+        status: "MERGED",
+        participants: [],
+        conferenceRoomId: null
+      };
+      logVoipDebug("makeCall() participant added", {
+        callId: this.activeCallId,
+        newParticipantNo: destination
+      });
+      return createSuccessResult("Participant added", session);
+    } catch (error) {
+      logVoipDebug("makeCall() failure", {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return createErrorResult(error instanceof Error ? error : "Failed to start call");
+    }
+  }
+  /** Start a parallel outbound call while another call is active (alias for `makeCall(to, { parallel: true })`). */
+  async addCall(to) {
+    return this.makeCall(to, { parallel: true });
+  }
+  /** All active call legs (parallel-aware). */
+  getActiveCallIds() {
+    return [...this.activeCallIds];
+  }
+  async acceptCall(callId) {
+    try {
+      const id = callId ?? this.activeCallId;
+      if (!id) return createErrorResult("No active call to answer");
+      await this.answerCall(id);
+      return createSuccessResult("Call accepted", null);
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to accept call");
+    }
+  }
+  async rejectCall(callId) {
+    try {
+      if (!this.bridge.nativeModule.rejectCall) {
+        return createErrorResult("rejectCall not supported by native module");
+      }
+      const result = await this.bridge.nativeModule.rejectCall({ callId });
+      if (!result.success) {
+        return createErrorResult(result.error ?? "Failed to reject call");
+      }
+      return createSuccessResult("Call rejected", null);
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to reject call");
+    }
+  }
+  async hangup(callId) {
+    try {
+      const id = callId ?? this.activeCallId;
+      if (!id) return createErrorResult("No active call to end");
+      await this.endCall(id);
+      return createSuccessResult("Call ended", null);
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to end call");
+    }
+  }
+  async hold(callId) {
+    try {
+      await this.holdCall(callId);
+      return createSuccessResult("Call held successfully", null);
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to hold call");
+    }
+  }
+  async resume(callId) {
+    try {
+      await this.resumeCall(callId);
+      return createSuccessResult("Call resumed successfully", null);
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to resume call");
+    }
+  }
+  async merge(callId) {
+    try {
+      const data = await this.mergeCall(callId);
+      return createSuccessResult("Call merged successfully", data);
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to merge call");
+    }
+  }
+  async toggleMute(mute, callId) {
+    const id = callId ?? this.activeCallId;
+    logVoipDebug("toggleMute() invoked", { mute, callId: id, hasActiveCall: Boolean(this.activeCallId) });
+    try {
+      if (!id) return createErrorResult("No active call");
+      await this.callEngine.toggleMute(id, mute);
+      return createSuccessResult(`Mute ${mute}`, null);
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to toggle mute");
+    }
+  }
+  async makeCallIncoming(to, callSid) {
+    logVoipDebug("makeCallIncoming() start", { to, callSid, hasActiveCall: Boolean(this.activeCallId) });
+    try {
+      const destination = to.trim();
+      if (!destination) return createErrorResult("Destination required");
+      if (!this.activeCallId) {
+        const data = await this.startCall(destination);
+        logVoipDebug("makeCallIncoming() new call started", { callId: data.callId });
+        return createSuccessResult("Call started", data);
+      }
+      await this.holdAndAddParticipantIncoming(callSid, destination);
+      const existingSession = this.callEngine.getSession(this.activeCallId);
+      const session = existingSession ?? {
+        callId: this.activeCallId,
+        direction: "INBOUND",
+        status: "MERGED",
+        participants: [],
+        conferenceRoomId: null
+      };
+      logVoipDebug("makeCallIncoming() participant added", { callId: this.activeCallId });
+      return createSuccessResult("Participant added", session);
+    } catch (error) {
+      logVoipDebug("makeCallIncoming() failure", {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return createErrorResult(error instanceof Error ? error : "Failed to start incoming call");
+    }
+  }
+  async holdAndAddParticipant(callSid, number) {
+    logVoipDebug("holdAndAddParticipant() invoked", { callSid, number });
+    this.ensureAuthenticated();
+    try {
+      if (!callSid) throw new Error("callSid is required.");
+      if (!number) throw new Error("Participant number is required.");
+      if (!this.internalConferenceName) throw new Error("conferenceName is not set.");
+      if (this.bridge.nativeModule.addNewCallee) {
+        const id = this.activeCallId ?? callSid;
+        const result = await this.bridge.nativeModule.addNewCallee({
+          callId: id,
+          newParticipantNo: number
+        });
+        if (!result.success) {
+          return createErrorResult(result.error ?? "Failed to add participant");
+        }
+        return createSuccessResult("Participant added successfully", result.data ?? {});
+      }
+      const holdId = this.activeCallId ?? callSid;
+      await this.holdCall(holdId);
+      const configService = this.configService;
+      const axiosInst = configService.axiosInstance ?? configService.deps?.axiosInstance;
+      if (!axiosInst) throw new Error("HTTP client not available");
+      const res = await axiosInst.post(
+        `${this.sdkConfig.serverUrl}/outgoingCall.addNewCallee`,
+        { conferenceName: this.internalConferenceName, newParticipantNo: number },
+        { headers: { Authorization: `Bearer ${this.sdkConfig.sdkToken}` } }
+      );
+      return createSuccessResult("Participant added successfully", res?.data?.result ?? res?.data);
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to add participant");
+    }
+  }
+  async holdAndAddParticipantIncoming(callSid, number) {
+    logVoipDebug("holdAndAddParticipantIncoming() invoked", { callSid, number });
+    this.ensureAuthenticated();
+    try {
+      if (!callSid) throw new Error("callSid is required.");
+      if (!number) throw new Error("Participant number is required.");
+      if (this.bridge.nativeModule.addNewCallee) {
+        const id = this.activeCallId ?? callSid;
+        const result = await this.bridge.nativeModule.addNewCallee({
+          callId: id,
+          newParticipantNo: number
+        });
+        if (!result.success) {
+          return createErrorResult(result.error ?? "Failed to add participant");
+        }
+        return createSuccessResult("Participant added successfully", result.data ?? {});
+      }
+      const holdId = this.activeCallId ?? callSid;
+      await this.holdCall(holdId);
+      const configService = this.configService;
+      const axiosInst = configService.axiosInstance ?? configService.deps?.axiosInstance;
+      if (!axiosInst) throw new Error("HTTP client not available");
+      const res = await axiosInst.post(
+        `${this.sdkConfig.serverUrl}/outgoingCall.addNewCalleeIncoming`,
+        { callSid, newParticipantNo: number },
+        { headers: { Authorization: `Bearer ${this.sdkConfig.sdkToken}` } }
+      );
+      return createSuccessResult("Participant added successfully", res?.data?.result ?? res?.data);
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to add participant");
+    }
+  }
+  async getConferenceId() {
+    logVoipDebug("getConferenceId() invoked");
+    this.ensureAuthenticated();
+    try {
+      if (!this.internalConferenceName) {
+        throw new Error("conferenceName is required to fetch conference details.");
+      }
+      if (this.bridge.nativeModule.getConferenceId) {
+        const result = await this.bridge.nativeModule.getConferenceId({
+          conferenceName: this.internalConferenceName
+        });
+        if (!result.success) {
+          return createErrorResult(result.error ?? "Failed to fetch conference details");
+        }
+        return createSuccessResult("Conference fetched successfully", result.data ?? null);
+      }
+      return createErrorResult("getConferenceId not supported");
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to fetch conference details");
+    }
+  }
+  async getParticipantsIncoming(callSid) {
+    logVoipDebug("getParticipantsIncoming() invoked", { callSid });
+    this.ensureAuthenticated();
+    try {
+      if (this.bridge.nativeModule.getParticipantsByCallSid) {
+        const result = await this.bridge.nativeModule.getParticipantsByCallSid({ callSid });
+        if (!result.success) {
+          return createErrorResult(result.error ?? "Failed to fetch participants");
+        }
+        return createSuccessResult("Participants fetched successfully", result.data ?? []);
+      }
+      return createErrorResult("getParticipantsByCallSid not supported");
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to fetch participants");
+    }
+  }
+  async getParticipantsOutgoing(callSid) {
+    logVoipDebug("getParticipantsOutgoing() invoked", { callSid });
+    this.ensureAuthenticated();
+    try {
+      if (this.bridge.nativeModule.getParticipantsByCallSid) {
+        const result = await this.bridge.nativeModule.getParticipantsByCallSid({ callSid });
+        if (!result.success) {
+          return createErrorResult(result.error ?? "Failed to fetch participants");
+        }
+        return createSuccessResult("Participants fetched successfully", result.data ?? []);
+      }
+      return createErrorResult("getParticipantsByCallSid not supported");
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to fetch participants");
+    }
+  }
+  async removeParticipant(conferenceSid, callSid) {
+    logVoipDebug("removeParticipant() invoked", { conferenceSid, callSid });
+    this.ensureAuthenticated();
+    try {
+      if (!conferenceSid) throw new Error("conferenceSid is required.");
+      if (!callSid) throw new Error("callSid is required.");
+      if (this.bridge.nativeModule.removeParticipant) {
+        const result = await this.bridge.nativeModule.removeParticipant({ conferenceSid, callSid });
+        if (!result.success) {
+          return createErrorResult(result.error ?? "Failed to remove participant");
+        }
+        return createSuccessResult("Participant removed successfully", result.data ?? {});
+      }
+      await this.disconnectParticipant(callSid);
+      return createSuccessResult("Participant removed successfully", null);
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error : "Failed to remove participant");
+    }
+  }
+  async getRoutingConfig() {
+    return this.configService.getRoutingConfig();
+  }
+  async setRoutingConfig(input) {
+    return this.configService.setRoutingConfig(input);
+  }
+  async createParseRule(input) {
+    return this.configService.createParseRule(input);
+  }
+  async listParseRules(input) {
+    return this.configService.listParseRules(input);
+  }
+  async registerWebhook(webhookUrl) {
+    return this.configService.registerWebhook(webhookUrl);
+  }
+  async deregisterWebhook() {
+    return this.configService.deregisterWebhook();
+  }
+  async isWebhookConfigured() {
+    return this.configService.isWebhookConfigured();
+  }
+  async welcomeMessageConfig(welcomeType, welcomeMessage) {
+    return this.configService.welcomeMessageConfig(welcomeType, welcomeMessage);
+  }
+  destroy() {
+    logVoipDebug("destroy() invoked");
+    this.unsubscribeOnCallEnded?.();
+    this.unsubscribeOnCallEnded = null;
+    this.authManager.destroy();
+    this.bridge.destroy();
+    this.initialized = false;
+    this.activeCallId = null;
+    this.activeCallIds.clear();
+    logVoipDebug("destroy() completed");
+  }
+  pickNextActiveCallId() {
+    if (this.activeCallIds.size === 0) return null;
+    return this.activeCallIds.values().next().value ?? null;
+  }
+  ensureAuthenticated() {
+    if (this.authManager.getState() !== "AUTHENTICATED") {
+      throw new Error("SDK not authenticated.");
+    }
+  }
+};
+
+// src/index.ts
+var ZyraTwilioWrapper = class extends ReactNativeVoipSdk {
+  constructor(config, nativeModule) {
+    super(config, nativeModule);
+    this.activeCallSid = null;
+    this.conferenceDetail = null;
+    this.participants = [];
+    this.waitUrl = "https://api.twilio.com/cowbell.mp3";
+    this.conferenceName = this.internalConferenceName;
+    this.waitUrl = config.waitUrl ?? this.waitUrl;
+    this.on("onReady", () => this.onReady?.());
+    this.on("onCallRinging", (payload) => this.onIncoming?.(payload));
+    this.on("onCallConnected", (payload) => {
+      if (typeof payload.callSid === "string") {
+        this.activeCallSid = payload.callSid;
+      }
+      if (payload.conferenceDetail) {
+        this.conferenceDetail = payload.conferenceDetail;
+      }
+      this.onConnect?.(payload);
+    });
+    this.on("onCallEnded", () => {
+      if (this.getActiveCallIds().length === 0) {
+        this.activeCallSid = null;
+        this.onDisconnect?.();
+      }
+    });
+    this.on("onMissedCall", () => {
+      this.activeCallSid = null;
+      this.onMissedCall?.();
+    });
+    this.on("onError", (payload) => {
+      const message = typeof payload.message === "string" ? payload.message : "Unknown SDK error";
+      this.onError?.(new Error(message));
+    });
+  }
+  destroy() {
+    this.activeCallSid = null;
+    this.conferenceDetail = null;
+    this.participants = [];
+    super.destroy();
+  }
+};
+export {
+  ReactNativeVoipSdk,
+  ZyraTwilioWrapper as default
+};
+//# sourceMappingURL=index.mjs.map