vg-x07df 1.2.0 → 1.3.0

package/dist/index.cjs

@@ -4,11 +4,15 @@ var React = require('react');
 var socket_ioClient = require('socket.io-client');
 var zustand = require('zustand');
 var immer = require('zustand/middleware/immer');
+var mitt = require('mitt');
 var zod = require('zod');
+var livekitClient = require('livekit-client');
+var componentsReact = require('@livekit/components-react');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var React__default = /*#__PURE__*/_interopDefault(React);
+var mitt__default = /*#__PURE__*/_interopDefault(mitt);
 
 // src/provider/RtcProvider.tsx
 
@@ -134,10 +138,10 @@ function setGlobalLoggerOptions(options) {
 
 // src/state/types.ts
 var defaultState = {
-  session: { status: "IDLE", initiatedByMe: false },
-  room: {
-    participants: {}
-  },
+  initiated: false,
+  session: null,
+  incomingInvite: null,
+  outgoingInvites: {},
   errors: []
 };
 
@@ -160,14 +164,14 @@ var useRtcStore = zustand.create()(
 var rtcStore = useRtcStore;
 
 // src/state/errors.ts
-function pushError(code, message, context, logger3) {
+function pushError(code, message, context, logger4) {
   const error = {
     code,
     message,
     timestamp: Date.now(),
     context
   };
-  logger3?.("error", message, { code, context });
+  logger4?.("error", message, { code, context });
   rtcStore.getState().addError(error);
 }
 function clearErrors(predicate) {
@@ -179,73 +183,73 @@ function clearErrors(predicate) {
     }
   });
 }
-function pushSocketValidationError(eventType, issues, payload, logger3) {
+function pushSocketValidationError(eventType, issues, payload, logger4) {
   pushError(
     "SOCKET_PAYLOAD",
     `Invalid ${eventType} event payload`,
     { eventType, issues, payload },
-    logger3
+    logger4
   );
 }
-function pushIdentityGuardError(reason, expected, received, logger3) {
+function pushIdentityGuardError(reason, expected, received, logger4) {
   pushError(
     "JOIN_FLOW",
     // Use new error code
     `Identity guard failed: ${reason}`,
     { expected, received },
-    logger3
+    logger4
   );
 }
-function pushLiveKitConnectError(message, error, logger3) {
+function pushLiveKitConnectError(message, error, logger4) {
   pushError(
     "LIVEKIT_CONNECT",
     `LiveKit connection failed: ${message}`,
     { originalError: error },
-    logger3
+    logger4
   );
 }
-function pushStaleEventError(eventType, reason, context, logger3) {
+function pushStaleEventError(eventType, reason, context, logger4) {
   pushError(
     "JOIN_FLOW",
     // Use new error code
     `Ignored stale ${eventType} event: ${reason}`,
     context,
-    logger3
+    logger4
   );
 }
-function pushApiError(operation, error, logger3) {
+function pushApiError(operation, error, logger4) {
   const errorMessage = error instanceof Error ? error.message : String(error);
   pushError(
     "API_ERROR",
     `API ${operation} failed: ${errorMessage}`,
     { operation, originalError: error },
-    logger3
+    logger4
   );
 }
-function pushNetworkError(operation, error, logger3) {
+function pushNetworkError(operation, error, logger4) {
   const errorMessage = error instanceof Error ? error.message : String(error);
   pushError(
     "NETWORK",
     `Network error during ${operation}: ${errorMessage}`,
     { operation, originalError: error },
-    logger3
+    logger4
   );
 }
-function pushMediaPermissionError(device, error, logger3) {
+function pushMediaPermissionError(device, error, logger4) {
   pushError(
     "MEDIA_PERMISSION",
     `${device} permission denied`,
     { device, originalError: error },
-    logger3
+    logger4
   );
 }
-function pushDeviceError(operation, device, error, logger3) {
+function pushDeviceError(operation, device, error, logger4) {
   const errorMessage = error instanceof Error ? error.message : String(error);
   pushError(
     "DEVICE_SWITCH",
     `Failed to ${operation} ${device}: ${errorMessage}`,
     { operation, device, originalError: error },
-    logger3
+    logger4
   );
 }
 
@@ -306,248 +310,37 @@ var BaseSocketHandler = class {
     return this.options.livekit;
   }
 };
-
-// src/utils/participant-adapter.ts
-function findCaller(participants) {
-  return participants.find((p) => p.role === "CALLER" || p.role === "HOST") || null;
-}
-function extractCallerInfo(participants) {
-  const caller = findCaller(participants);
-  if (!caller) return null;
-  const result = {
-    id: caller.id,
-    name: [caller.firstName, caller.lastName].filter(Boolean).join(" ") || `Guest ${caller.id}`
-  };
-  if (caller.profilePhoto) {
-    result.avatarUrl = caller.profilePhoto;
-  }
-  return result;
-}
-
-// src/core/events/event-bus.ts
-var logger = createLogger("core:event-bus");
 var EventBus = class {
-  constructor(debugMode = false) {
-    this.listeners = /* @__PURE__ */ new Map();
-    this.isDebugMode = false;
-    this.eventHistory = [];
-    this.maxHistorySize = 100;
-    this.isDebugMode = debugMode;
-  }
-  /**
-   * Subscribe to events of a specific type
-   */
-  on(eventType, handler, filter) {
-    const actualHandler = filter ? (event) => {
-      if (filter(event)) {
-        handler(event);
-      }
-    } : handler;
-    if (!this.listeners.has(eventType)) {
-      this.listeners.set(eventType, /* @__PURE__ */ new Set());
-    }
-    this.listeners.get(eventType)?.add(actualHandler);
-    if (this.isDebugMode) {
-      logger.debug(`Event listener added for: ${eventType}`, {
-        eventType,
-        totalListeners: this.listeners.get(eventType)?.size
-      });
-    }
-    return {
-      unsubscribe: () => {
-        const handlers = this.listeners.get(eventType);
-        if (handlers) {
-          handlers.delete(actualHandler);
-          if (handlers.size === 0) {
-            this.listeners.delete(eventType);
-          }
-        }
-        if (this.isDebugMode) {
-          logger.debug(`Event listener removed for: ${eventType}`, {
-            eventType,
-            remainingListeners: handlers?.size || 0
-          });
-        }
-      }
-    };
+  constructor() {
+    this.emitter = mitt__default.default();
   }
-  /**
-   * Subscribe to events matching a pattern (e.g., "call:*")
-   */
-  onPattern(pattern, handler, filter) {
-    const regex = new RegExp(pattern.replace(/\*/g, ".*"));
-    const patternHandler = (event) => {
-      if (regex.test(event.type)) {
-        if (filter && !filter(event)) return;
-        handler(event);
-      }
+  on(eventType, handler) {
+    const wrappedHandler = (event) => {
+      handler(event);
     };
-    const patternKey = `__pattern__${pattern}`;
-    if (!this.listeners.has(patternKey)) {
-      this.listeners.set(patternKey, /* @__PURE__ */ new Set());
-    }
-    this.listeners.get(patternKey)?.add(patternHandler);
-    if (this.isDebugMode) {
-      logger.debug(`Pattern listener added: ${pattern}`, { pattern });
-    }
+    this.emitter.on(eventType.toString(), wrappedHandler);
     return {
       unsubscribe: () => {
-        const handlers = this.listeners.get(patternKey);
-        if (handlers) {
-          handlers.delete(patternHandler);
-          if (handlers.size === 0) {
-            this.listeners.delete(patternKey);
-          }
-        }
-        if (this.isDebugMode) {
-          logger.debug(`Pattern listener removed: ${pattern}`, { pattern });
-        }
+        this.emitter.off(eventType.toString(), wrappedHandler);
       }
     };
   }
-  /**
-   * Subscribe to a single event occurrence
-   */
-  once(eventType, handler, filter) {
-    const subscription = this.on(
-      eventType,
-      (event) => {
-        handler(event);
-        subscription.unsubscribe();
-      },
-      filter
-    );
-    return subscription;
-  }
-  /**
-   * Emit an event
-   */
-  emit(eventType, payload, source = "user") {
+  emit(eventType, payload) {
     const event = {
       type: eventType.toString(),
       payload,
-      timestamp: Date.now(),
-      source
+      timestamp: Date.now()
     };
-    this.addToHistory(event);
-    if (this.isDebugMode) {
-      logger.debug(`Event emitted: ${eventType}`, {
-        eventType,
-        payload,
-        source,
-        timestamp: event.timestamp
-      });
-    }
-    const exactListeners = this.listeners.get(eventType.toString());
-    if (exactListeners) {
-      for (const handler of exactListeners) {
-        try {
-          handler(event);
-        } catch (error) {
-          logger.error(`Error in event handler for ${eventType}`, {
-            error,
-            eventType,
-            payload
-          });
-        }
-      }
-    }
-    this.listeners.forEach((handlers, key) => {
-      if (key.startsWith("__pattern__")) {
-        for (const handler of handlers) {
-          try {
-            handler(event);
-          } catch (error) {
-            logger.error(`Error in pattern handler for ${eventType}`, {
-              error,
-              eventType,
-              pattern: key,
-              payload
-            });
-          }
-        }
-      }
-    });
+    this.emitter.emit(eventType.toString(), event);
   }
-  /**
-   * Remove all listeners for a specific event type
-   */
   off(eventType) {
-    this.listeners.delete(eventType.toString());
-    if (this.isDebugMode) {
-      logger.debug(`All listeners removed for: ${eventType}`, { eventType });
-    }
+    this.emitter.off(eventType.toString());
   }
-  /**
-   * Remove all listeners
-   */
   removeAllListeners() {
-    const totalListeners = Array.from(this.listeners.values()).reduce(
-      (sum, handlers) => sum + handlers.size,
-      0
-    );
-    this.listeners.clear();
-    if (this.isDebugMode) {
-      logger.debug("All listeners removed", { removedCount: totalListeners });
-    }
-  }
-  /**
-   * Get the count of listeners for an event type
-   */
-  listenerCount(eventType) {
-    return this.listeners.get(eventType.toString())?.size || 0;
-  }
-  /**
-   * Get all event types that have listeners
-   */
-  getEventTypes() {
-    return Array.from(this.listeners.keys());
-  }
-  /**
-   * Enable or disable debug mode
-   */
-  setDebugMode(enabled) {
-    this.isDebugMode = enabled;
-    logger.debug(`Debug mode ${enabled ? "enabled" : "disabled"}`);
-  }
-  /**
-   * Get event history for debugging
-   */
-  getEventHistory() {
-    return [...this.eventHistory];
-  }
-  /**
-   * Clear event history
-   */
-  clearHistory() {
-    this.eventHistory = [];
-    if (this.isDebugMode) {
-      logger.debug("Event history cleared");
-    }
-  }
-  /**
-   * Get events matching a filter
-   */
-  getEventsWhere(filter) {
-    return this.eventHistory.filter(filter);
-  }
-  addToHistory(event) {
-    this.eventHistory.push(event);
-    if (this.eventHistory.length > this.maxHistorySize) {
-      this.eventHistory.shift();
-    }
-  }
-  /**
-   * Set maximum history size
-   */
-  setMaxHistorySize(size) {
-    this.maxHistorySize = size;
-    if (this.eventHistory.length > size) {
-      this.eventHistory = this.eventHistory.slice(-size);
-    }
+    this.emitter.all.clear();
   }
 };
-var eventBus = new EventBus(false);
+var eventBus = new EventBus();
 
 // src/core/events/types.ts
 var SdkEventType = /* @__PURE__ */ ((SdkEventType2) => {
@@ -572,163 +365,482 @@ var SdkEventType = /* @__PURE__ */ ((SdkEventType2) => {
   SdkEventType2["ERROR_OCCURRED"] = "error:occurred";
   return SdkEventType2;
 })(SdkEventType || {});
-var socketParticipantSchema = zod.z.object({
-  id: zod.z.string(),
-  firstName: zod.z.string().nullable(),
-  lastName: zod.z.string().nullable(),
-  username: zod.z.string().nullable(),
-  profilePhoto: zod.z.string().nullable(),
-  role: zod.z.enum(["CALLER", "CALLEE", "HOST", "MEMBER"]).optional()
-});
-var callIncomingSchema = zod.z.object({
+var callCancelledSchema = zod.z.object({
   callId: zod.z.string(),
-  type: zod.z.enum(["AUDIO", "VIDEO"]),
-  participants: zod.z.array(socketParticipantSchema).min(1),
-  // Required, at least 1 participant
-  timestamp: zod.z.number()
-});
-var callParticipantAcceptedSchema = zod.z.object({
-  callId: zod.z.string(),
-  participantId: zod.z.string(),
-  participant: socketParticipantSchema,
-  acceptedAt: zod.z.string().optional()
-});
-var callJoinInfoSchema = zod.z.object({
+  status: zod.z.literal("cancelled"),
+  cancelledAt: zod.z.string()
+}).strict();
+var callCreatedSchema = zod.z.object({
   callId: zod.z.string(),
-  token: zod.z.string(),
-  url: zod.z.string().optional(),
+  status: zod.z.literal("pending"),
   roomName: zod.z.string(),
-  expiresAt: zod.z.number().optional()
-});
+  createdAt: zod.z.string(),
+  host: zod.z.object({
+    firstName: zod.z.string().nullable(),
+    lastName: zod.z.string().nullable(),
+    username: zod.z.string().nullable(),
+    email: zod.z.string().nullable(),
+    profilePhoto: zod.z.string().nullable(),
+    userId: zod.z.string()
+  }).strict(),
+  participants: zod.z.array(zod.z.object({
+    firstName: zod.z.string().nullable(),
+    lastName: zod.z.string().nullable(),
+    username: zod.z.string().nullable(),
+    email: zod.z.string().nullable(),
+    profilePhoto: zod.z.string().nullable(),
+    userId: zod.z.string()
+  }).strict())
+}).strict();
 var callEndedSchema = zod.z.object({
   callId: zod.z.string(),
-  reason: zod.z.string().optional(),
-  endedAt: zod.z.string().optional()
-}).passthrough();
-var callTimeoutSchema = zod.z.object({
+  endedAt: zod.z.string(),
+  endedByUserId: zod.z.string().optional(),
+  reason: zod.z.string().optional()
+}).strict();
+var callInviteSchema = zod.z.object({
   callId: zod.z.string(),
-  reason: zod.z.string().optional(),
-  timestamp: zod.z.number().optional()
-});
-var callParticipantDeclinedSchema = zod.z.object({
+  status: zod.z.enum(["pending", "active", "ended"]),
+  caller: zod.z.object({
+    firstName: zod.z.string().nullable(),
+    lastName: zod.z.string().nullable(),
+    username: zod.z.string().nullable(),
+    email: zod.z.string().nullable(),
+    profilePhoto: zod.z.string().nullable(),
+    userId: zod.z.string()
+  }).strict(),
+  mode: zod.z.enum(["VIDEO", "AUDIO"]),
+  expiresAt: zod.z.string(),
+  expiresInMs: zod.z.number()
+}).strict();
+var callInviteAcceptedSchema = zod.z.object({
+  callId: zod.z.string(),
+  status: zod.z.enum(["pending", "active", "ended"]),
+  participant: zod.z.object({
+    firstName: zod.z.string().nullable(),
+    lastName: zod.z.string().nullable(),
+    username: zod.z.string().nullable(),
+    email: zod.z.string().nullable(),
+    profilePhoto: zod.z.string().nullable(),
+    userId: zod.z.string()
+  }).strict(),
+  acceptedAt: zod.z.string()
+}).strict();
+var callInviteCancelledSchema = zod.z.object({
   callId: zod.z.string(),
-  participantId: zod.z.string(),
-  participant: socketParticipantSchema,
-  declinedAt: zod.z.string().optional()
-});
-var callCanceledSchema = zod.z.object({
+  status: zod.z.enum(["pending", "active", "ended"]),
+  cancelledByUserId: zod.z.string(),
+  cancelledAt: zod.z.string(),
+  reason: zod.z.string()
+}).strict();
+var callInviteDeclinedSchema = zod.z.object({
   callId: zod.z.string(),
+  status: zod.z.enum(["pending", "active", "ended"]),
+  participant: zod.z.object({
+    firstName: zod.z.string().nullable(),
+    lastName: zod.z.string().nullable(),
+    username: zod.z.string().nullable(),
+    email: zod.z.string().nullable(),
+    profilePhoto: zod.z.string().nullable(),
+    userId: zod.z.string()
+  }).strict(),
   reason: zod.z.string().optional(),
-  timestamp: zod.z.number().optional(),
-  by: socketParticipantSchema.optional()
-});
+  declinedAt: zod.z.string()
+}).strict();
+var callInviteMissedSchema = zod.z.object({
+  callId: zod.z.string(),
+  status: zod.z.enum(["pending", "active", "ended"]),
+  participant: zod.z.object({
+    firstName: zod.z.string().nullable(),
+    lastName: zod.z.string().nullable(),
+    username: zod.z.string().nullable(),
+    email: zod.z.string().nullable(),
+    profilePhoto: zod.z.string().nullable(),
+    userId: zod.z.string()
+  }).strict(),
+  missedAt: zod.z.string()
+}).strict();
+var callInviteSentSchema = zod.z.object({
+  callId: zod.z.string(),
+  invitee: zod.z.object({
+    firstName: zod.z.string().nullable(),
+    lastName: zod.z.string().nullable(),
+    username: zod.z.string().nullable(),
+    email: zod.z.string().nullable(),
+    profilePhoto: zod.z.string().nullable(),
+    userId: zod.z.string()
+  }).strict(),
+  status: zod.z.literal("sent")
+}).strict();
+var callJoinInfoSchema = zod.z.object({
+  callId: zod.z.string(),
+  token: zod.z.string(),
+  roomName: zod.z.string(),
+  lkUrl: zod.z.string(),
+  role: zod.z.enum(["HOST", "PARTICIPANT", "GUEST"]),
+  participantId: zod.z.string().optional()
+}).strict();
+var callMissedSchema = zod.z.object({
+  callId: zod.z.string(),
+  endedAt: zod.z.string()
+}).strict();
+var callParticipantAddedSchema = zod.z.object({
+  callId: zod.z.string(),
+  status: zod.z.enum(["pending", "active", "ended"]),
+  participant: zod.z.object({
+    participantId: zod.z.string(),
+    userId: zod.z.string(),
+    firstName: zod.z.string().optional(),
+    lastName: zod.z.string().optional(),
+    username: zod.z.string().optional(),
+    email: zod.z.string().optional(),
+    profilePhoto: zod.z.string().optional(),
+    role: zod.z.enum(["HOST", "PARTICIPANT", "GUEST"]),
+    joinState: zod.z.enum(["not_joined", "joined"])
+  }).strict()
+}).strict();
 
-// src/core/socketio/handlers/call-incoming.handler.ts
-var CallIncomingHandler = class extends BaseSocketHandler {
+// src/core/socketio/handlers/invite.handler.ts
+var InviteHandler = class extends BaseSocketHandler {
   constructor() {
     super(...arguments);
-    this.eventName = "call.incoming";
-    this.schema = callIncomingSchema;
+    this.eventName = "call:invite";
+    this.schema = callInviteSchema;
   }
   handle(data) {
-    const callerInfo = extractCallerInfo(data.participants);
-    if (!callerInfo) {
-      this.logger.error("No active caller found in participants", data);
-      return;
-    }
+    this.logger.info("Incoming call invitation", {
+      callId: data.callId,
+      caller: data.caller.userId,
+      mode: data.mode
+    });
     this.updateStore((state) => {
+      state.incomingInvite = {
+        callId: data.callId,
+        caller: {
+          userId: data.caller.userId,
+          firstName: data.caller.firstName,
+          lastName: data.caller.lastName,
+          username: data.caller.username,
+          email: data.caller.email,
+          profilePhoto: data.caller.profilePhoto
+        },
+        mode: data.mode,
+        expiresAt: data.expiresAt,
+        expiresInMs: data.expiresInMs
+      };
       state.session = {
         id: data.callId,
-        status: "RINGING",
-        mode: data.type,
-        initiatedByMe: false
+        status: "pending",
+        mode: data.mode,
+        role: "PARTICIPANT"
       };
-      state.room.participants = {};
     });
-    eventBus.emit(
-      "call:incoming" /* CALL_INCOMING */,
-      {
-        callId: data.callId,
-        caller: callerInfo,
-        type: data.type,
-        timestamp: data.timestamp,
-        participants: data.participants
+    eventBus.emit("call:incoming" /* CALL_INCOMING */, {
+      callId: data.callId,
+      caller: {
+        id: data.caller.userId,
+        firstName: data.caller.firstName,
+        lastName: data.caller.lastName,
+        avatarUrl: data.caller.profilePhoto
       },
-      "socket"
-    );
-    this.logger.debug("Incoming call event emitted", {
+      type: data.mode,
+      timestamp: Date.now()
+    });
+    this.logger.debug("Incoming invite state updated");
+  }
+};
+
+// src/core/socketio/handlers/invite-sent.handler.ts
+var InviteSentHandler = class extends BaseSocketHandler {
+  constructor() {
+    super(...arguments);
+    this.eventName = "call:inviteSent";
+    this.schema = callInviteSentSchema;
+  }
+  handle(data) {
+    const currentState = rtcStore.getState();
+    this.logger.info("Invitation sent to participant", {
+      callId: data.callId,
+      invitee: data.invitee.userId
+    });
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:inviteSent", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id
+      });
+      this.logger.warn("Ignoring invite sent for different call", { callId: data.callId });
+      return;
+    }
+    this.updateStore((state) => {
+      const userId = data.invitee.userId;
+      state.outgoingInvites[userId] = {
+        userId,
+        status: "sent",
+        participant: {
+          userId: data.invitee.userId,
+          firstName: data.invitee.firstName,
+          lastName: data.invitee.lastName,
+          username: data.invitee.username,
+          email: data.invitee.email,
+          profilePhoto: data.invitee.profilePhoto
+        }
+      };
+    });
+    eventBus.emit("participant:invited" /* PARTICIPANT_INVITED */, {
+      callId: data.callId,
+      participant: {
+        id: data.invitee.userId,
+        firstName: data.invitee.firstName,
+        lastName: data.invitee.lastName,
+        avatarUrl: data.invitee.profilePhoto
+      },
+      timestamp: Date.now()
+    });
+    this.logger.debug("Outgoing invite tracked", {
+      userId: data.invitee.userId
+    });
+  }
+};
+
+// src/core/socketio/handlers/invite-accepted.handler.ts
+var InviteAcceptedHandler = class extends BaseSocketHandler {
+  constructor() {
+    super(...arguments);
+    this.eventName = "call:inviteAccepted";
+    this.schema = callInviteAcceptedSchema;
+  }
+  handle(data) {
+    const currentState = rtcStore.getState();
+    this.logger.info("Participant accepted invitation", {
       callId: data.callId,
-      caller: callerInfo.name,
-      type: data.type
+      participant: data.participant.userId
+    });
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:inviteAccepted", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id
+      });
+      this.logger.warn("Ignoring accept event for different call", { callId: data.callId });
+      return;
+    }
+    this.updateStore((state) => {
+      const userId = data.participant.userId;
+      if (state.outgoingInvites[userId]) {
+        state.outgoingInvites[userId].status = "accepted";
+      } else {
+        state.outgoingInvites[userId] = {
+          userId,
+          status: "accepted",
+          participant: {
+            userId: data.participant.userId,
+            firstName: data.participant.firstName,
+            lastName: data.participant.lastName,
+            username: data.participant.username,
+            email: data.participant.email,
+            profilePhoto: data.participant.profilePhoto
+          }
+        };
+      }
+    });
+    this.logger.debug("Outgoing invite marked as accepted", {
+      userId: data.participant.userId
     });
   }
 };
 
-// src/core/socketio/handlers/call-accepted.handler.ts
-var CallParticipantAcceptedHandler = class extends BaseSocketHandler {
+// src/core/socketio/handlers/invite-declined.handler.ts
+var InviteDeclinedHandler = class extends BaseSocketHandler {
   constructor() {
     super(...arguments);
-    this.eventName = "call.participant-accepted";
-    this.schema = callParticipantAcceptedSchema;
+    this.eventName = "call:inviteDeclined";
+    this.schema = callInviteDeclinedSchema;
   }
-  async handle(data) {
+  handle(data) {
     const currentState = rtcStore.getState();
-    if (currentState.session.id !== data.callId) {
-      pushStaleEventError("call.participant-accepted", "callId mismatch", {
+    this.logger.info("Participant declined invitation", {
+      callId: data.callId,
+      participant: data.participant.userId,
+      reason: data.reason
+    });
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:inviteDeclined", "callId mismatch", {
         eventCallId: data.callId,
-        sessionCallId: currentState.session.id
+        sessionCallId: currentState.session?.id
       });
+      this.logger.warn("Ignoring decline event for different call", { callId: data.callId });
       return;
     }
     this.updateStore((state) => {
-      state.session.status = "ACCEPTED";
+      const userId = data.participant.userId;
+      if (state.outgoingInvites[userId]) {
+        state.outgoingInvites[userId].status = "declined";
+      } else {
+        state.outgoingInvites[userId] = {
+          userId,
+          status: "declined",
+          participant: {
+            userId: data.participant.userId,
+            firstName: data.participant.firstName,
+            lastName: data.participant.lastName,
+            username: data.participant.username,
+            email: data.participant.email,
+            profilePhoto: data.participant.profilePhoto
+          }
+        };
+      }
+    });
+    eventBus.emit("call:declined" /* CALL_DECLINED */, {
+      callId: data.callId,
+      participantId: data.participant.userId,
+      reason: data.reason,
+      timestamp: Date.now()
+    });
+    this.logger.debug("Outgoing invite marked as declined", {
+      userId: data.participant.userId
     });
   }
 };
 
-// src/core/socketio/handlers/call-declined.handler.ts
-var CallParticipantDeclinedHandler = class extends BaseSocketHandler {
+// src/core/socketio/handlers/invite-missed.handler.ts
+var InviteMissedHandler = class extends BaseSocketHandler {
   constructor() {
     super(...arguments);
-    this.eventName = "call.participant-declined";
-    this.schema = callParticipantDeclinedSchema;
+    this.eventName = "call:inviteMissed";
+    this.schema = callInviteMissedSchema;
   }
   handle(data) {
+    const currentState = rtcStore.getState();
+    this.logger.info("Participant missed invitation", {
+      callId: data.callId,
+      participant: data.participant.userId
+    });
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:inviteMissed", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id
+      });
+      this.logger.warn("Ignoring missed invite for different call", { callId: data.callId });
+      return;
+    }
     this.updateStore((state) => {
-      if (state.session.id === data.callId) {
-        state.session.status = "IDLE";
+      const userId = data.participant.userId;
+      if (state.outgoingInvites[userId]) {
+        state.outgoingInvites[userId].status = "missed";
+      } else {
+        state.outgoingInvites[userId] = {
+          userId,
+          status: "missed",
+          participant: {
+            userId: data.participant.userId,
+            firstName: data.participant.firstName,
+            lastName: data.participant.lastName,
+            username: data.participant.username,
+            email: data.participant.email,
+            profilePhoto: data.participant.profilePhoto
+          }
+        };
       }
     });
-    eventBus.emit(
-      "call:declined" /* CALL_DECLINED */,
-      {
-        callId: data.callId,
-        participantId: data.participantId,
-        reason: "declined",
-        timestamp: Date.now()
-      },
-      "socket"
-    );
+    this.logger.debug("Outgoing invite marked as missed", {
+      userId: data.participant.userId
+    });
+  }
+};
+
+// src/core/socketio/handlers/invite-cancelled.handler.ts
+var InviteCancelledHandler = class extends BaseSocketHandler {
+  constructor() {
+    super(...arguments);
+    this.eventName = "call:inviteCancelled";
+    this.schema = callInviteCancelledSchema;
+  }
+  handle(data) {
+    const currentState = rtcStore.getState();
+    this.logger.info("Invitation cancelled by host", {
+      callId: data.callId,
+      cancelledBy: data.cancelledByUserId,
+      reason: data.reason
+    });
+    if (currentState.incomingInvite?.callId !== data.callId) {
+      this.logger.debug("Ignoring cancelled invite for different call", {
+        callId: data.callId
+      });
+      return;
+    }
+    this.updateStore((state) => {
+      state.incomingInvite = null;
+      state.session = null;
+    });
+    eventBus.emit("call:canceled" /* CALL_CANCELED */, {
+      callId: data.callId,
+      reason: data.reason,
+      timestamp: Date.now()
+    });
+    this.logger.debug("Incoming invite cleared due to cancellation");
+  }
+};
+
+// src/core/socketio/handlers/call-created.handler.ts
+var SessionCreatedHandler = class extends BaseSocketHandler {
+  constructor() {
+    super(...arguments);
+    this.eventName = "call:created";
+    this.schema = callCreatedSchema;
+  }
+  handle(data) {
+    this.logger.info("Call session created", {
+      callId: data.callId,
+      roomName: data.roomName,
+      host: data.host.userId,
+      participantCount: data.participants.length
+    });
+    this.updateStore((state) => {
+      state.initiated = true;
+      state.session = {
+        id: data.callId,
+        status: "pending",
+        mode: "VIDEO",
+        role: "HOST"
+      };
+      state.outgoingInvites = {};
+    });
+    eventBus.emit("call:initiated" /* CALL_INITIATED */, {
+      callId: data.callId,
+      participants: data.participants.map((p) => p.userId),
+      type: "VIDEO",
+      // Default, TODO: get from API request context
+      timestamp: Date.now()
+    });
+    this.logger.debug("Session created for outbound call");
   }
 };
 
 // src/core/socketio/handlers/call-ended.handler.ts
-var CallEndedHandler = class extends BaseSocketHandler {
+var SessionEndedHandler = class extends BaseSocketHandler {
   constructor() {
     super(...arguments);
-    this.eventName = "call.ended";
+    this.eventName = "call:ended";
     this.schema = callEndedSchema;
   }
   handle(data) {
+    const currentState = rtcStore.getState();
+    this.logger.info("Call session ended", {
+      callId: data.callId,
+      endedBy: data.endedByUserId,
+      reason: data.reason
+    });
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:ended", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id
+      });
+      this.logger.warn("Ignoring end event for different call", { callId: data.callId });
+      return;
+    }
     this.updateStore((state) => {
-      if (state.session.id !== data.callId) {
-        pushStaleEventError("call.ended", "callId mismatch", {
-          eventCallId: data.callId,
-          sessionCallId: state.session.id
-        });
-        return;
-      }
-      state.session.status = "ENDED";
+      state.initiated = false;
+      state.session = null;
+      state.outgoingInvites = {};
       state.room.participants = {};
     });
     if (this.livekit) {
@@ -736,83 +848,165 @@ var CallEndedHandler = class extends BaseSocketHandler {
         this.logger.error("Error disconnecting from LiveKit", { error });
       });
     }
+    eventBus.emit("call:ended" /* CALL_ENDED */, {
+      callId: data.callId,
+      endedBy: data.endedByUserId,
+      reason: "user",
+      timestamp: Date.now()
+    });
+    this.logger.debug("Session cleared and LiveKit disconnected");
   }
 };
 
-// src/core/socketio/handlers/call-join-info.handler.ts
-var CallJoinInfoHandler = class extends BaseSocketHandler {
+// src/core/socketio/handlers/call-cancelled.handler.ts
+var SessionCancelledHandler = class extends BaseSocketHandler {
   constructor() {
     super(...arguments);
-    this.eventName = "call.join-info";
-    this.schema = callJoinInfoSchema;
+    this.eventName = "call:cancelled";
+    this.schema = callCancelledSchema;
   }
-  async handle(data) {
+  handle(data) {
+    const currentState = rtcStore.getState();
+    this.logger.info("Call session cancelled", {
+      callId: data.callId,
+      status: data.status
+    });
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:cancelled", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id
+      });
+      this.logger.warn("Ignoring cancel event for different call", { callId: data.callId });
+      return;
+    }
     this.updateStore((state) => {
-      state.session.livekitInfo = {
-        token: data.token,
-        url: data.url,
-        roomName: data.roomName,
-        callId: data.callId
-      };
-      state.session.status = "READY_TO_JOIN";
+      state.initiated = false;
+      state.session = null;
+      state.outgoingInvites = {};
+      state.room.participants = {};
     });
-    eventBus.emit(
-      "join-info:received" /* JOIN_INFO_RECEIVED */,
-      {
-        callId: data.callId,
-        timestamp: Date.now(),
-        url: data.url,
-        roomName: data.roomName,
-        token: data.token
-      },
-      "socket"
-    );
+    eventBus.emit("call:canceled" /* CALL_CANCELED */, {
+      callId: data.callId,
+      reason: "cancelled by host",
+      timestamp: Date.now()
+    });
+    this.logger.debug("Session cleared due to cancellation");
   }
 };
 
-// src/core/socketio/handlers/call-timeout.handler.ts
-var CallTimeoutHandler = class extends BaseSocketHandler {
+// src/core/socketio/handlers/call-missed.handler.ts
+var SessionMissedHandler = class extends BaseSocketHandler {
   constructor() {
     super(...arguments);
-    this.eventName = "call.timeout";
-    this.schema = callTimeoutSchema;
+    this.eventName = "call:missed";
+    this.schema = callMissedSchema;
   }
   handle(data) {
-    const reason = data.reason || "timeout";
-    this.logger.info(`Call timeout: ${reason}`, { callId: data.callId });
+    const currentState = rtcStore.getState();
+    this.logger.info("Call missed by all participants", {
+      callId: data.callId
+    });
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:missed", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id
+      });
+      this.logger.warn("Ignoring missed call for different session", { callId: data.callId });
+      return;
+    }
     this.updateStore((state) => {
-      if (state.session.id === data.callId) {
-        state.session.status = "ENDED";
-        state.room.participants = {};
-      }
+      state.initiated = false;
+      state.session = null;
+      state.outgoingInvites = {};
+      state.room.participants = {};
+    });
+    eventBus.emit("call:timeout" /* CALL_TIMEOUT */, {
+      callId: data.callId,
+      reason: "All participants missed/declined",
+      timestamp: Date.now()
     });
+    this.logger.debug("Session cleared - call was missed by all");
   }
 };
 
-// src/core/socketio/handlers/call-canceled.handler.ts
-var CallCanceledHandler = class extends BaseSocketHandler {
+// src/core/socketio/handlers/join-info.handler.ts
+var JoinInfoHandler = class extends BaseSocketHandler {
   constructor() {
     super(...arguments);
-    this.eventName = "call.canceled";
-    this.schema = callCanceledSchema;
+    this.eventName = "call:joinInfo";
+    this.schema = callJoinInfoSchema;
   }
   handle(data) {
-    const reason = data.reason || "canceled";
-    this.logger.info(`Call canceled: ${reason}`, {
+    const currentState = rtcStore.getState();
+    this.logger.info("Received LiveKit join info", {
       callId: data.callId,
-      by: data.by?.id
+      roomName: data.roomName,
+      role: data.role
     });
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:joinInfo", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id
+      });
+      this.logger.warn("Ignoring join info for unknown call", { callId: data.callId });
+      return;
+    }
     this.updateStore((state) => {
-      if (state.session.id === data.callId) {
-        state.session.status = "ENDED";
-        state.room.participants = {};
+      if (state.session?.id === data.callId) {
+        state.session.livekitInfo = {
+          token: data.token,
+          roomName: data.roomName,
+          url: data.lkUrl
+        };
+        state.session.role = data.role;
       }
     });
+    eventBus.emit("join-info:received" /* JOIN_INFO_RECEIVED */, {
+      callId: data.callId,
+      participantId: data.participantId || "",
+      timestamp: Date.now(),
+      url: data.lkUrl,
+      token: data.token
+    });
+    this.logger.debug("Session updated with LiveKit credentials");
+  }
+};
+
+// src/core/socketio/handlers/participant-added.handler.ts
+var ParticipantAddedHandler = class extends BaseSocketHandler {
+  constructor() {
+    super(...arguments);
+    this.eventName = "call:participantAdded";
+    this.schema = callParticipantAddedSchema;
+  }
+  handle(data) {
+    const currentState = rtcStore.getState();
+    this.logger.info("Participant added to call", {
+      callId: data.callId,
+      participantId: data.participant.participantId,
+      userId: data.participant.userId,
+      role: data.participant.role
+    });
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:participantAdded", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id
+      });
+      this.logger.warn("Ignoring participant added for different call", { callId: data.callId });
+      return;
+    }
+    eventBus.emit("participant:updated" /* PARTICIPANT_UPDATED */, {
+      participantId: data.participant.participantId,
+      timestamp: Date.now()
+    });
+    this.logger.debug("Participant added event processed", {
+      participantId: data.participant.participantId
+    });
   }
 };
 
 // src/core/socketio/handlers/handler.registry.ts
-var logger2 = createLogger("socketio:registry");
+var logger = createLogger("socketio:registry");
 var SocketHandlerRegistry = class {
   constructor(options = {}) {
     this.options = options;
@@ -821,34 +1015,52 @@ var SocketHandlerRegistry = class {
   }
   initializeHandlers() {
     const handlers = [
-      new CallIncomingHandler(this.options),
-      new CallParticipantAcceptedHandler(this.options),
-      new CallParticipantDeclinedHandler(this.options),
-      new CallEndedHandler(this.options),
-      new CallJoinInfoHandler(this.options),
-      new CallTimeoutHandler(this.options),
-      new CallCanceledHandler(this.options)
+      // Phase 1: Core flow handlers
+      new InviteHandler(this.options),
+      new JoinInfoHandler(this.options),
+      new SessionEndedHandler(this.options),
+      new SessionCreatedHandler(this.options),
+      // Phase 2: Invite management handlers
+      new InviteAcceptedHandler(this.options),
+      new InviteDeclinedHandler(this.options),
+      new InviteCancelledHandler(this.options),
+      new InviteSentHandler(this.options),
+      // Phase 3: Edge case handlers
+      new InviteMissedHandler(this.options),
+      new SessionCancelledHandler(this.options),
+      new SessionMissedHandler(this.options),
+      new ParticipantAddedHandler(this.options)
     ];
     for (const handler of handlers) {
       this.handlers.set(handler.eventName, handler);
     }
+    logger.info(`Registered ${handlers.length} socket event handlers`);
   }
   registerEventListeners(socket) {
     for (const [eventName, handler] of this.handlers) {
       socket.on(eventName, (rawData) => {
         handler.handleRaw(rawData).catch((error) => {
-          logger2.error(`Handler error for ${eventName}:`, error);
+          logger.error(`Handler error for ${eventName}:`, error);
         });
       });
     }
+    logger.debug("Event listeners registered on socket");
   }
   removeEventListeners(socket) {
     for (const eventName of this.handlers.keys()) {
       socket.off(eventName);
     }
+    logger.debug("Event listeners removed from socket");
   }
   destroy() {
     this.handlers.clear();
+    logger.debug("Handler registry destroyed");
+  }
+  /**
+   * Get all registered event names
+   */
+  getRegisteredEvents() {
+    return Array.from(this.handlers.keys());
   }
 };
 
@@ -1402,17 +1614,17 @@ var request = (config, options) => {
 // src/generated/api/services.ts
 var CallsService = class {
   /**
-   * @returns any Call started successfully
+   * @returns any Invites sent successfully
    * @throws ApiError
    */
-  static postSignalCalls(data) {
+  static postSignalCallsInvite(data) {
     const {
       appId,
       requestBody
     } = data;
     return request(OpenAPI, {
       method: "POST",
-      url: "/signal/calls",
+      url: "/signal/calls/invite",
       query: {
         appId
       },
@@ -1420,7 +1632,9 @@ var CallsService = class {
       mediaType: "application/json",
       errors: {
         400: `Invalid request`,
-        401: `Authentication required`
+        401: `Authentication required`,
+        403: `User does not have permission to invite`,
+        404: `Call not found`
       }
     });
   }
@@ -1458,7 +1672,8 @@ var CallsService = class {
   static postSignalCallsByCallIdDecline(data) {
     const {
       callId,
-      appId
+      appId,
+      requestBody
     } = data;
     return request(OpenAPI, {
       method: "POST",
@@ -1469,6 +1684,8 @@ var CallsService = class {
       query: {
         appId
       },
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
         400: `Invalid request`,
         401: `Authentication required`,
@@ -1479,17 +1696,17 @@ var CallsService = class {
     });
   }
   /**
-   * @returns any Left call successfully
+   * @returns any Call cancelled successfully
    * @throws ApiError
    */
-  static postSignalCallsByCallIdLeave(data) {
+  static postSignalCallsByCallIdCancel(data) {
     const {
       callId,
       appId
     } = data;
     return request(OpenAPI, {
       method: "POST",
-      url: "/signal/calls/{callId}/leave",
+      url: "/signal/calls/{callId}/cancel",
       path: {
         callId
       },
@@ -1499,151 +1716,180 @@ var CallsService = class {
       errors: {
         400: `Invalid request`,
         401: `Authentication required`,
-        403: `User is not a participant`,
+        403: `User does not have permission to cancel`,
         404: `Call not found`,
-        409: `Call cannot be left in current state`
+        409: `Call cannot be cancelled in current state`
       }
     });
   }
   /**
-   * @returns any Call retrieved successfully
+   * @returns any Transfer initiated successfully
    * @throws ApiError
    */
-  static getSignalCallsByCallId(data) {
+  static postSignalCallsByCallIdTransfer(data) {
     const {
       callId,
-      appId
+      appId,
+      requestBody
     } = data;
     return request(OpenAPI, {
-      method: "GET",
-      url: "/signal/calls/{callId}",
+      method: "POST",
+      url: "/signal/calls/{callId}/transfer",
       path: {
         callId
       },
       query: {
         appId
       },
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
         400: `Invalid request`,
         401: `Authentication required`,
-        403: `User does not have access to this call`,
-        404: `Call not found`
+        403: `User does not have permission to transfer`,
+        404: `Call not found`,
+        409: `Call cannot be transferred in current state`
       }
     });
   }
   /**
-   * @returns any Participant info retrieved successfully
+   * @returns any Participant kicked successfully
    * @throws ApiError
    */
-  static getSignalCallsParticipantsByIdentity(data) {
+  static postSignalCallsByCallIdKick(data) {
     const {
-      identity,
-      appId
+      callId,
+      appId,
+      requestBody
     } = data;
     return request(OpenAPI, {
-      method: "GET",
-      url: "/signal/calls/participants/{identity}",
+      method: "POST",
+      url: "/signal/calls/{callId}/kick",
       path: {
-        identity
+        callId
       },
       query: {
         appId
       },
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
         400: `Invalid request`,
         401: `Authentication required`,
-        404: `Participant not found`
+        403: `User does not have permission to kick`,
+        404: `Call not found`,
+        409: `Participant cannot be kicked in current state`
       }
     });
   }
-};
-
-// src/core/signal/signal.client.ts
-var SignalClient = class {
-  constructor(config) {
-    this.logger = createLogger("signal");
-    this.config = config;
-  }
-  async initiate(params) {
-    try {
-      return await CallsService.postSignalCalls({
-        appId: this.config.appId,
-        requestBody: {
-          mode: params.mode || "AUDIO",
-          participants: params.invitees.map((userId) => ({ userId }))
-        }
-      });
-    } catch (error) {
-      this.handleApiError("initiate", error);
-      throw error;
-    }
-  }
-  async accept(callId) {
-    try {
-      const response = await CallsService.postSignalCallsByCallIdAccept({
-        callId,
-        appId: this.config.appId
-      });
-      return {
-        ...response,
-        callId,
-        state: "ACTIVE",
-        message: "Call accepted"
-      };
-    } catch (error) {
-      this.handleApiError("accept", error);
-      throw error;
-    }
-  }
-  async decline(callId) {
-    try {
-      const response = await CallsService.postSignalCallsByCallIdDecline({
-        callId,
-        appId: this.config.appId
-      });
-      return {
-        ...response,
-        callId,
-        state: "ENDED",
-        message: "Call declined"
-      };
-    } catch (error) {
-      this.handleApiError("decline", error);
-      throw error;
-    }
+  /**
+   * @returns any Participant muted successfully
+   * @throws ApiError
+   */
+  static postSignalCallsByCallIdMute(data) {
+    const {
+      callId,
+      appId,
+      requestBody
+    } = data;
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/signal/calls/{callId}/mute",
+      path: {
+        callId
+      },
+      query: {
+        appId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Invalid request`,
+        401: `Authentication required`,
+        403: `User does not have permission to mute`,
+        404: `Call not found`,
+        409: `Participant cannot be muted in current state`
+      }
+    });
   }
-  async leave(callId) {
-    try {
-      const response = await CallsService.postSignalCallsByCallIdLeave({
-        callId,
-        appId: this.config.appId
-      });
-      return {
-        ...response,
-        callId,
-        state: "ENDED",
-        message: "Left call"
-      };
-    } catch (error) {
-      this.handleApiError("leave", error);
-      throw error;
-    }
+  /**
+   * @returns any Call ended successfully
+   * @throws ApiError
+   */
+  static postSignalCallsByCallIdEnd(data) {
+    const {
+      callId,
+      appId
+    } = data;
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/signal/calls/{callId}/end",
+      path: {
+        callId
+      },
+      query: {
+        appId
+      },
+      errors: {
+        400: `Invalid request`,
+        401: `Authentication required`,
+        403: `Only host can end call`,
+        404: `Call not found`
+      }
+    });
   }
-  handleApiError(operation, error) {
-    const errorMessage = error?.body?.message || error?.message || "Unknown error";
-    const errorCode = error?.status || error?.code || "UNKNOWN";
-    this.logger.error(`Signal API error during ${operation}`, {
-      operation,
-      errorCode,
-      errorMessage,
-      error
+  /**
+   * @returns any Left call successfully
+   * @throws ApiError
+   */
+  static postSignalCallsByCallIdLeave(data) {
+    const {
+      callId,
+      appId
+    } = data;
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/signal/calls/{callId}/leave",
+      path: {
+        callId
+      },
+      query: {
+        appId
+      },
+      errors: {
+        400: `Invalid request`,
+        401: `Authentication required`,
+        404: `Call not found`
+      }
     });
   }
 };
 
 // src/core/signal/api.config.ts
+var logger2 = createLogger("api-config");
 var OpenApiConfigService = class _OpenApiConfigService {
   constructor() {
+    this.configured = false;
+    OpenAPI.interceptors.request.use((request2) => {
+      const headers = request2.headers;
+      let authHeader = null;
+      if (headers instanceof Headers) {
+        authHeader = headers.get("Authorization") || null;
+      } else if (headers && typeof headers === "object") {
+        authHeader = headers["Authorization"] || null;
+      }
+      if (authHeader) {
+        logger2.debug("API Request with Authorization header", {
+          hasAuth: true,
+          authPrefix: authHeader.substring(0, 20) + "..."
+        });
+      } else {
+        logger2.warn("API Request WITHOUT Authorization header", {
+          hasAuth: false
+        });
+      }
+      return request2;
+    });
   }
   static getInstance() {
     if (!_OpenApiConfigService.instance) {
@@ -1657,7 +1903,15 @@ var OpenApiConfigService = class _OpenApiConfigService {
       const tokenFn = config.token;
       OpenAPI.TOKEN = async (_options) => {
         const result = tokenFn();
-        return typeof result === "string" ? result : await result;
+        const token = typeof result === "string" ? result : await result;
+        if (!token) {
+          logger2.warn("Token provider returned empty token");
+        } else {
+          logger2.debug("Token resolved successfully", {
+            tokenPrefix: token.substring(0, 10) + "..."
+          });
+        }
+        return token;
       };
     } else {
       OpenAPI.TOKEN = config.token;
@@ -1667,6 +1921,14 @@ var OpenApiConfigService = class _OpenApiConfigService {
     if (config.headers) {
       OpenAPI.HEADERS = config.headers;
     }
+    this.configured = true;
+    logger2.info("API configuration completed", {
+      baseUrl: config.baseUrl,
+      hasToken: !!config.token
+    });
+  }
+  isConfigured() {
+    return this.configured;
   }
   setToken(token) {
     OpenAPI.TOKEN = token;
@@ -1674,92 +1936,119 @@ var OpenApiConfigService = class _OpenApiConfigService {
 };
 var apiConfig = OpenApiConfigService.getInstance();
 
-// src/services/call-actions.ts
-function createCallActions(signal, auth) {
-  const logger3 = createLogger("call-actions");
+// src/services/calls.service.ts
+var logger3 = createLogger("calls-service");
+function createCallsService(config) {
+  const { appId } = config;
+  const ensureApiConfigured = () => {
+    if (!apiConfig.isConfigured()) {
+      logger3.error("API not configured before making call service request");
+      throw new Error(
+        "API configuration missing. Ensure the SDK is properly initialized."
+      );
+    }
+  };
   async function initiate(params) {
-    const response = await signal.initiate(params);
-    rtcStore.getState().patch((state) => {
-      state.session = {
-        id: response.id,
-        status: "CALLING",
-        // Caller initiated, waiting for acceptance
-        mode: response.mode,
-        // Identity context: I initiated this call, so I'm the caller
-        myRole: "CALLER",
-        initiatedByMe: true
-      };
-      state.room.participants = {};
-      logger3.debug("Call initiated - waiting for participants to join", {
-        callId: response.id,
-        invitedCount: response.participants?.length || 0
-      });
+    ensureApiConfigured();
+    const requestBody = {
+      mode: params.mode || "AUDIO",
+      participants: params.invitees.map((userId) => ({ userId }))
+    };
+    if (params.callId) {
+      requestBody.callId = params.callId;
+    }
+    return CallsService.postSignalCallsInvite({
+      appId,
+      requestBody
     });
-    return response;
   }
   async function accept(callId) {
-    const response = await signal.accept(callId);
-    rtcStore.getState().patch((state) => {
-      state.session = {
-        ...state.session,
-        id: callId,
-        status: "ACCEPTED",
-        // Call accepted but not yet joined media
-        myRole: "CALLEE",
-        initiatedByMe: false
-      };
-      state.room.participants = {};
+    ensureApiConfigured();
+    return CallsService.postSignalCallsByCallIdAccept({
+      callId,
+      appId
     });
-    return response;
   }
   async function decline(callId, reason) {
-    logger3.debug("Starting decline action", { callId, reason });
-    try {
-      const response = await signal.decline(callId);
-      logger3.info("Decline API success", { callId, response });
-      rtcStore.getState().patch((state) => {
-        if (state.session.id === callId) {
-          state.session.status = response.state;
-        }
-      });
-      eventBus.emit(
-        "call:declined" /* CALL_DECLINED */,
-        {
-          callId,
-          reason,
-          timestamp: Date.now()
-        },
-        "user"
-      );
-      return response;
-    } catch (error) {
-      logger3.error("Decline API failed", { callId, error });
-      rtcStore.getState().patch((state) => {
-        state.session.status = "IDLE";
-        logger3.warn("Force-cleared session due to API failure");
-      });
-      eventBus.emit(
-        "call:declined" /* CALL_DECLINED */,
-        {
-          callId,
-          reason: "api_error",
-          timestamp: Date.now()
-        },
-        "user"
-      );
-      throw error;
+    ensureApiConfigured();
+    const payload = {
+      callId,
+      appId
+    };
+    if (reason) {
+      payload.requestBody = { reason };
     }
+    return CallsService.postSignalCallsByCallIdDecline(payload);
+  }
+  async function cancel(callId) {
+    ensureApiConfigured();
+    return CallsService.postSignalCallsByCallIdCancel({
+      callId,
+      appId
+    });
   }
   async function leave(callId) {
-    rtcStore.getState().patch((state) => {
-      state.session.status = "IDLE";
+    ensureApiConfigured();
+    return CallsService.postSignalCallsByCallIdLeave({
+      callId,
+      appId
+    });
+  }
+  async function end(callId) {
+    ensureApiConfigured();
+    return CallsService.postSignalCallsByCallIdEnd({
+      callId,
+      appId
+    });
+  }
+  async function transfer(callId, targetParticipantId, reason) {
+    ensureApiConfigured();
+    const requestBody = {
+      targetParticipantId
+    };
+    if (reason) {
+      requestBody.reason = reason;
+    }
+    return CallsService.postSignalCallsByCallIdTransfer({
+      callId,
+      appId,
+      requestBody
+    });
+  }
+  async function kick(callId, participantId, reason) {
+    ensureApiConfigured();
+    const requestBody = {
+      participantId
+    };
+    if (reason) {
+      requestBody.reason = reason;
+    }
+    return CallsService.postSignalCallsByCallIdKick({
+      callId,
+      appId,
+      requestBody
+    });
+  }
+  async function mute(callId, participantId) {
+    ensureApiConfigured();
+    return CallsService.postSignalCallsByCallIdMute({
+      callId,
+      appId,
+      requestBody: {
+        participantId
+      }
     });
   }
   return {
     initiate,
     accept,
     decline,
-    leave
+    cancel,
+    leave,
+    end,
+    transfer,
+    kick,
+    mute
   };
 }
 
@@ -1778,12 +2067,14 @@ function buildSdk(opts) {
   setGlobalLoggerOptions(loggerOptions);
   const auth = new AuthManager(opts.authProvider);
   const socket = SocketManager.getInstance();
-  const signal = new SignalClient({
+  const callsService = createCallsService({ appId: opts.appId });
+  apiConfig.configure({
     baseUrl: opts.signalHost,
-    appId: opts.appId,
-    authManager: auth
+    token: async () => {
+      const token = auth.getCurrentToken();
+      return token || "";
+    }
   });
-  const callActions = createCallActions(signal);
   const cleanup = () => {
     socket.destroy();
     rtcStore.getState().reset();
@@ -1792,10 +2083,9 @@ function buildSdk(opts) {
     store: rtcStore,
     auth,
     socket,
-    signal,
-    ...callActions,
+    calls: callsService,
     cleanup,
-    // API configuration
+    // API configuration - can be called again to override if needed
     configureApi: (config) => {
       apiConfig.configure(config);
     }
@@ -1810,24 +2100,6 @@ function RtcProvider({
 }) {
   const sdk = React.useMemo(() => buildSdk(options), [options]);
   React.useEffect(() => {
-    try {
-      sdk.configureApi({
-        baseUrl: options.signalHost,
-        token: async () => {
-          const token = sdk.auth.getCurrentToken();
-          return token || "";
-        }
-      });
-      options.log?.("info", "API configured successfully");
-    } catch (error) {
-      options.log?.("error", "Failed to configure API", error);
-      rtcStore.getState().addError({
-        code: "API_CONFIG_ERROR",
-        message: "Failed to configure API",
-        timestamp: Date.now(),
-        context: error
-      });
-    }
     sdk.socket.initialize(
       options.signalHost,
       sdk.auth,
@@ -1862,36 +2134,104 @@ var useSdk = () => {
 // src/hooks/useCallState.ts
 function useCallState() {
   const session = useRtcStore((state) => state.session);
+  if (!session) {
+    return {
+      id: null,
+      status: null,
+      mode: null,
+      roomName: null
+    };
+  }
   return {
     id: session.id,
     status: session.status,
     mode: session.mode,
-    roomName: session.livekitInfo?.roomName
+    roomName: session.livekitInfo?.roomName || null
   };
 }
 
+// src/hooks/useSessionId.ts
+function useSessionId() {
+  return useRtcStore((state) => state.session?.id ?? null);
+}
+
+// src/hooks/useIncomingInvite.ts
+function useIncomingInvite() {
+  return useRtcStore((state) => state.incomingInvite);
+}
+
 // src/hooks/useCallActions.ts
 function useCallActions() {
   const sdk = useSdk();
+  const sessionId = useSessionId();
+  const incomingInvite = useIncomingInvite();
   return {
     initiate: (participants, type) => {
-      return sdk.initiate({ invitees: participants, mode: type });
+      return sdk.calls.initiate({ invitees: participants, mode: type });
+    },
+    invite: (participants) => {
+      if (!sessionId) {
+        throw new Error("No active session to invite participants to");
+      }
+      const session = sdk.store.getState().session;
+      const mode = session?.mode || "VIDEO";
+      return sdk.calls.initiate({
+        invitees: participants,
+        mode,
+        callId: sessionId
+      });
+    },
+    accept: () => {
+      if (!incomingInvite) {
+        throw new Error("No incoming invite to accept");
+      }
+      return sdk.calls.accept(incomingInvite.callId);
+    },
+    decline: (reason) => {
+      if (!incomingInvite) {
+        throw new Error("No incoming invite to decline");
+      }
+      return sdk.calls.decline(incomingInvite.callId, reason);
+    },
+    cancel: () => {
+      if (!sessionId) {
+        throw new Error("No active session to cancel");
+      }
+      return sdk.calls.cancel(sessionId);
+    },
+    leave: () => {
+      if (!sessionId) {
+        throw new Error("No active session to leave");
+      }
+      return sdk.calls.leave(sessionId);
     },
-    accept: (callId) => {
-      return sdk.accept(callId);
+    end: () => {
+      if (!sessionId) {
+        throw new Error("No active session to end");
+      }
+      return sdk.calls.end(sessionId);
     },
-    decline: (callId) => {
-      return sdk.decline(callId);
+    transfer: (targetParticipantId, reason) => {
+      if (!sessionId) {
+        throw new Error("No active session to transfer");
+      }
+      return sdk.calls.transfer(sessionId, targetParticipantId, reason);
     },
-    end: (callId) => {
-      return sdk.leave(callId);
+    kick: (participantId, reason) => {
+      if (!sessionId) {
+        throw new Error("No active session to kick participant from");
+      }
+      return sdk.calls.kick(sessionId, participantId, reason);
     },
-    cancel: (callId) => {
-      return sdk.leave(callId);
+    mute: (participantId) => {
+      if (!sessionId) {
+        throw new Error("No active session to mute participant in");
+      }
+      return sdk.calls.mute(sessionId, participantId);
     }
   };
 }
-function useEvent(eventType, callback, filter) {
+function useEvent(eventType, callback) {
   const [lastEvent, setLastEvent] = React.useState(
     void 0
   );
@@ -1904,17 +2244,111 @@ function useEvent(eventType, callback, filter) {
         callbackRef.current(event);
       }
     };
-    const subscription = eventType.includes("*") ? eventBus.onPattern(eventType, handler, filter) : eventBus.on(eventType, handler, filter);
+    const subscription = eventBus.on(eventType, handler);
     return () => {
       subscription.unsubscribe();
     };
-  }, [eventType, filter]);
+  }, [eventType]);
   return lastEvent;
 }
 
+// src/hooks/useOutgoingInvites.ts
+function useOutgoingInvites() {
+  return useRtcStore((state) => state.outgoingInvites);
+}
+
+// src/hooks/useInviteAccepted.ts
+function useInviteAccepted() {
+  return useRtcStore((state) => {
+    return Object.values(state.outgoingInvites).some(
+      (invite) => invite.status === "accepted"
+    );
+  });
+}
+
+// src/hooks/useCallInitiated.ts
+function useCallInitiated() {
+  return useRtcStore((state) => state.initiated);
+}
+
+// src/hooks/useSessionDuration.ts
+function useSessionDuration() {
+  return 0;
+}
+var defaultRoomOptions = {
+  adaptiveStream: true,
+  dynacast: true
+};
+function useRoom(options) {
+  const [room] = React.useState(() => new livekitClient.Room(options || defaultRoomOptions));
+  const livekitInfo = useRtcStore((state) => state.session?.livekitInfo);
+  React.useEffect(() => {
+    if (!livekitInfo) {
+      return;
+    }
+    room.connect(livekitInfo.url, livekitInfo.token);
+    return () => {
+      room.disconnect();
+    };
+  }, [livekitInfo, room]);
+  if (!livekitInfo) {
+    return null;
+  }
+  return room;
+}
+function useParticipantMetadata(participantOrIdentity) {
+  const room = useRoom();
+  const participants = componentsReact.useParticipants(room ? { room } : {});
+  let resolvedParticipant;
+  if (typeof participantOrIdentity === "string") {
+    resolvedParticipant = participants.find(
+      (p) => p.identity === participantOrIdentity
+    );
+  } else if (participantOrIdentity) {
+    resolvedParticipant = participantOrIdentity;
+  }
+  const livekitInfo = componentsReact.useParticipantInfo(
+    resolvedParticipant ? { participant: resolvedParticipant } : {}
+  );
+  if (!livekitInfo.metadata) {
+    return null;
+  }
+  try {
+    const metadata = JSON.parse(livekitInfo.metadata);
+    if (!metadata.userId || !metadata.role) {
+      console.warn("Invalid participant metadata: missing required fields", metadata);
+      return null;
+    }
+    return {
+      userId: metadata.userId,
+      role: metadata.role,
+      firstName: metadata.firstName || "",
+      lastName: metadata.lastName || "",
+      username: metadata.username || "",
+      email: metadata.email || "",
+      profilePhoto: metadata.profilePhoto || ""
+    };
+  } catch (error) {
+    console.error("Failed to parse participant metadata:", error);
+    return null;
+  }
+}
+
 exports.RtcProvider = RtcProvider;
 exports.SdkEventType = SdkEventType;
 exports.apiConfig = apiConfig;
+exports.callCancelledSchema = callCancelledSchema;
+exports.callCreatedSchema = callCreatedSchema;
+exports.callEndedSchema = callEndedSchema;
+exports.callInviteAcceptedSchema = callInviteAcceptedSchema;
+exports.callInviteCancelledSchema = callInviteCancelledSchema;
+exports.callInviteDeclinedSchema = callInviteDeclinedSchema;
+exports.callInviteMissedSchema = callInviteMissedSchema;
+exports.callInviteSchema = callInviteSchema;
+exports.callInviteSentSchema = callInviteSentSchema;
+exports.callJoinInfoSchema = callJoinInfoSchema;
+exports.callMissedSchema = callMissedSchema;
+exports.callParticipantAddedSchema = callParticipantAddedSchema;
 exports.clearErrors = clearErrors;
 exports.eventBus = eventBus;
 exports.pushApiError = pushApiError;
@@ -1927,8 +2361,16 @@ exports.pushNetworkError = pushNetworkError;
 exports.pushSocketValidationError = pushSocketValidationError;
 exports.pushStaleEventError = pushStaleEventError;
 exports.useCallActions = useCallActions;
+exports.useCallInitiated = useCallInitiated;
 exports.useCallState = useCallState;
 exports.useEvent = useEvent;
+exports.useIncomingInvite = useIncomingInvite;
+exports.useInviteAccepted = useInviteAccepted;
+exports.useOutgoingInvites = useOutgoingInvites;
+exports.useParticipantMetadata = useParticipantMetadata;
+exports.useRoom = useRoom;
 exports.useSdk = useSdk;
+exports.useSessionDuration = useSessionDuration;
+exports.useSessionId = useSessionId;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map