vg-x07df 1.10.6 → 1.11.1

package/dist/index.mjs

@@ -1,10 +1,10 @@
 import React, { createContext, useMemo, useEffect, useContext, useState, useRef, useReducer, useCallback } from 'react';
-import { io } from 'socket.io-client';
 import { create } from 'zustand';
 import { immer } from 'zustand/middleware/immer';
-import { z } from 'zod';
-import { enableMapSet } from 'immer';
 import mitt from 'mitt';
+import { enableMapSet } from 'immer';
+import { io } from 'socket.io-client';
+import { z } from 'zod';
 import { VideoPresets, ConnectionState, Room, RoomEvent, Track } from 'livekit-client';
 import { useConnectionState as useConnectionState$1, useRoomContext, useLocalParticipant, useParticipants, useTracks } from '@livekit/components-react';
 import { BackgroundProcessor } from '@livekit/track-processors';
@@ -1290,227 +1290,6 @@ var parseTimeInput = (input) => {
   return Number.isFinite(timestamp) ? timestamp : null;
 };
 
-// src/clients/signal/config.ts
-var logger = createLogger("api-config");
-var OpenApiConfigService = class _OpenApiConfigService {
-  constructor() {
-    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) {
-        logger.debug("API Request with Authorization header", {
-          hasAuth: true,
-          authPrefix: `${authHeader.substring(0, 20)}...`
-        });
-      } else {
-        logger.warn("API Request WITHOUT Authorization header", {
-          hasAuth: false
-        });
-      }
-      return request2;
-    });
-  }
-  static getInstance() {
-    if (!_OpenApiConfigService.instance) {
-      _OpenApiConfigService.instance = new _OpenApiConfigService();
-    }
-    return _OpenApiConfigService.instance;
-  }
-  configure(config) {
-    OpenAPI.BASE = config.baseUrl;
-    if (typeof config.token === "function") {
-      const tokenFn = config.token;
-      OpenAPI.TOKEN = async (_options) => {
-        const result = tokenFn();
-        const token = typeof result === "string" ? result : await result;
-        if (!token) {
-          logger.warn("Token provider returned empty token");
-        } else {
-          logger.debug("Token resolved successfully", {
-            tokenPrefix: `${token.substring(0, 10)}...`
-          });
-        }
-        return token;
-      };
-    } else {
-      OpenAPI.TOKEN = config.token;
-    }
-    OpenAPI.CREDENTIALS = config.credentials ?? "include";
-    OpenAPI.WITH_CREDENTIALS = config.withCredentials ?? false;
-    if (config.headers) {
-      OpenAPI.HEADERS = config.headers;
-    }
-    logger.info("Signal svc configuration completed", {
-      baseUrl: config.baseUrl,
-      hasToken: !!config.token
-    });
-  }
-};
-var apiConfig = OpenApiConfigService.getInstance();
-
-// src/core/session-storage.ts
-var SessionStorage = class {
-  constructor(key) {
-    this.key = key;
-  }
-  set(data) {
-    const serialized = JSON.stringify(data);
-    sessionStorage.setItem(this.key, serialized);
-  }
-  get() {
-    const stored = sessionStorage.getItem(this.key);
-    if (!stored) {
-      return null;
-    }
-    try {
-      return JSON.parse(stored);
-    } catch {
-      return null;
-    }
-  }
-  clear() {
-    sessionStorage.removeItem(this.key);
-  }
-  exists() {
-    return sessionStorage.getItem(this.key) !== null;
-  }
-};
-
-// src/core/auth.manager.ts
-var logger2 = createLogger("auth-manager");
-var DEFAULT_AUTH_RETRY_CONFIG = {
-  maxRetries: 10,
-  initialDelayMs: 200,
-  maxDelayMs: 5e3,
-  backoffMultiplier: 2
-};
-var AuthManager = class {
-  constructor(authProvider, appId, retryConfig) {
-    this.lastToken = null;
-    this.initializePromise = null;
-    this.authProvider = authProvider;
-    this.appId = appId;
-    this.sessionStorage = new SessionStorage(
-      "callpad_session_info"
-    );
-    this.retryConfig = { ...DEFAULT_AUTH_RETRY_CONFIG, ...retryConfig };
-  }
-  async acquireTokenWithRetry() {
-    const { maxRetries, initialDelayMs, maxDelayMs, backoffMultiplier } = this.retryConfig;
-    let delay = initialDelayMs;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      const token = this.authProvider();
-      if (token) {
-        if (attempt > 0) {
-          logger2.debug("Token acquired after retry", { attempt });
-        }
-        return token;
-      }
-      if (attempt < maxRetries) {
-        logger2.debug("Auth token not available, retrying", {
-          attempt: attempt + 1,
-          maxRetries,
-          delayMs: delay
-        });
-        await new Promise((resolve2) => setTimeout(resolve2, delay));
-        delay = Math.min(delay * backoffMultiplier, maxDelayMs);
-      }
-    }
-    throw new Error(
-      `No authentication token available after ${maxRetries} retries. This may indicate the auth provider is temporarily unavailable (e.g., token refresh in progress).`
-    );
-  }
-  async initialize(appId) {
-    try {
-      const token = await this.acquireTokenWithRetry();
-      const originalToken = OpenAPI.TOKEN;
-      OpenAPI.TOKEN = token;
-      try {
-        logger2.debug("Initializing session", { appId });
-        const response = await InitService.getSignalInit({ appId });
-        const sessionInfo = {
-          sessionToken: response.sessionToken,
-          sessionId: response.sessionId,
-          userId: response.userId,
-          deviceId: response.deviceId,
-          expiresAt: response.expiresAt
-        };
-        this.sessionStorage.set(sessionInfo);
-        logger2.info("Session initialized successfully", {
-          sessionId: sessionInfo.sessionId,
-          userId: sessionInfo.userId
-        });
-      } finally {
-        OpenAPI.TOKEN = originalToken;
-      }
-    } catch (error) {
-      logger2.error("Failed to initialize session", { appId, error });
-      throw new Error(`Session initialization failed: ${error}`);
-    }
-  }
-  async getSessionToken() {
-    const sessionInfo = this.sessionStorage.get();
-    if (sessionInfo) {
-      return sessionInfo.sessionToken;
-    }
-    if (!this.initializePromise) {
-      this.initializePromise = this.initialize(this.appId);
-    }
-    try {
-      await this.initializePromise;
-      const newSessionInfo = this.sessionStorage.get();
-      return newSessionInfo?.sessionToken || null;
-    } catch (error) {
-      logger2.error("Failed to get session token", { error });
-      return null;
-    }
-  }
-  getSessionInfo() {
-    return this.sessionStorage.get();
-  }
-  getCurrentToken() {
-    const token = this.authProvider();
-    if (token !== this.lastToken) {
-      this.lastToken = token;
-    }
-    return token;
-  }
-};
-
-// src/core/guest-auth.manager.ts
-var GuestAuthManager = class {
-  constructor(appId, deviceId) {
-    this.appId = appId;
-    this.deviceId = deviceId;
-    this.sessionStorage = new SessionStorage(
-      "callpad_guest_session"
-    );
-  }
-  getAppId() {
-    return this.appId;
-  }
-  getDeviceId() {
-    return this.deviceId;
-  }
-  setSession(session) {
-    this.sessionStorage.set(session);
-  }
-  async getSessionToken() {
-    return this.sessionStorage.get()?.sessionToken || null;
-  }
-  getSessionInfo() {
-    return this.sessionStorage.get();
-  }
-  clearSession() {
-    this.sessionStorage.clear();
-  }
-};
-
 // src/state/types.ts
 var defaultState = {
   initiated: false,
@@ -1539,35 +1318,6 @@ var useRtcStore = create()(
   }))
 );
 var rtcStore = useRtcStore;
-
-// src/core/socketio/handlers/base.handler.ts
-var BaseSocketHandler = class {
-  constructor(options = {}) {
-    this.options = options;
-  }
-  get logger() {
-    if (!this._logger) {
-      this._logger = createLogger(`socketio:${this.eventName}`);
-    }
-    return this._logger;
-  }
-  async handleRaw(rawData) {
-    this.logger.info(`${this.eventName} received`, rawData);
-    try {
-      await this.handle(JSON.parse(JSON.stringify(rawData)));
-      this.logger.debug(`${this.eventName} handled successfully`);
-    } catch (error) {
-      this.logger.error(`${this.eventName} handler error`, error);
-      throw error;
-    }
-  }
-  updateStore(updater) {
-    rtcStore.getState().patch(updater);
-  }
-  get livekit() {
-    return this.options.livekit;
-  }
-};
 var defaultChatState = {
   byId: {},
   order: [],
@@ -1863,182 +1613,63 @@ var useSpotlightStore = create()(
     }))
   }))
 );
-var callEndedSchema = z.object({
-  callId: z.string(),
-  endedAt: z.string(),
-  endedByUserId: z.string().optional()
-}).strict();
-var callInviteSchema = z.object({
-  inviteId: z.string(),
-  callId: z.string(),
-  userId: z.string(),
-  callerId: z.string(),
-  mode: z.enum(["VIDEO", "AUDIO"]),
-  invitedAt: z.string()
-}).strict();
-var callInviteAcceptedSchema = z.object({
-  callId: z.string(),
-  userId: z.string(),
-  acceptedAt: z.string()
-}).strict();
-var callInviteCancelledSchema = z.object({
-  callId: z.string(),
-  cancelledByUserId: z.string(),
-  cancelledAt: z.string(),
-  reason: z.string()
-}).strict();
-var callInviteDeclinedSchema = z.object({
-  callId: z.string(),
-  userId: z.string(),
-  reason: z.string().optional(),
-  declinedAt: z.string()
-}).strict();
-var callInviteMissedSchema = z.object({
-  callId: z.string(),
-  userId: z.string(),
-  missedAt: z.string()
-}).strict();
-var callParticipantAddedSchema = z.object({
-  callId: z.string(),
-  userId: z.string(),
-  participantId: z.string()
-}).strict();
-var callParticipantKickedSchema = z.object({
-  callId: z.string(),
-  participantId: z.string(),
-  userId: z.string(),
-  reason: z.string().optional()
-}).strict();
-var callParticipantLeftSchema = z.object({
-  callId: z.string(),
-  userId: z.string(),
-  participantId: z.string(),
-  leftAt: z.string(),
-  reason: z.string().optional()
-}).strict();
-var callReadySchema = z.object({
-  callId: z.string(),
-  participantId: z.string().optional(),
-  userId: z.string(),
-  message: z.string()
-}).strict();
-var callRecordingStartedSchema = z.object({
-  callId: z.string(),
-  recordingId: z.string(),
-  egressId: z.string(),
-  initiatedBy: z.string().optional(),
-  startedAt: z.string()
-}).strict();
-var callRecordingStoppedSchema = z.object({
-  callId: z.string(),
-  recordingId: z.string(),
-  egressId: z.string(),
-  stoppedAt: z.string()
-}).strict();
-var callStartedSchema = z.object({
-  callId: z.string(),
-  startedAt: z.string()
-}).strict();
-var participantProfilesSchema = z.object({
-  profiles: z.array(z.object({
-    userId: z.string(),
-    username: z.string().nullable(),
-    firstName: z.string().nullable(),
-    lastName: z.string().nullable(),
-    profilePhoto: z.string().nullable()
-  }).strict())
-}).strict();
-var presencePingSchema = z.object({}).strict();
+var EventBus = class {
+  constructor() {
+    this.emitter = mitt();
+  }
+  on(eventType, handler) {
+    const wrappedHandler = (event) => {
+      handler(event);
+    };
+    this.emitter.on(eventType.toString(), wrappedHandler);
+    return {
+      unsubscribe: () => {
+        this.emitter.off(eventType.toString(), wrappedHandler);
+      }
+    };
+  }
+  emit(eventType, payload) {
+    const event = {
+      type: eventType.toString(),
+      payload,
+      timestamp: Date.now()
+    };
+    this.emitter.emit(eventType.toString(), event);
+  }
+  off(eventType) {
+    this.emitter.off(eventType.toString());
+  }
+  removeAllListeners() {
+    this.emitter.all.clear();
+  }
+};
+var eventBus = new EventBus();
 
-// src/state/errors.ts
-function pushError(code, message, context, logger7) {
-  const error = {
-    code,
-    message,
-    timestamp: Date.now(),
-    context
-  };
-  logger7?.("error", message, { code, context });
-  rtcStore.getState().addError(error);
-}
-function clearErrors(predicate) {
-  rtcStore.getState().patch((state) => {
-    if (predicate) {
-      state.errors = state.errors.filter((error) => !predicate(error));
-    } else {
-      state.errors = [];
-    }
-  });
-}
-function pushSocketValidationError(eventType, issues, payload, logger7) {
-  pushError(
-    "SOCKET_PAYLOAD",
-    `Invalid ${eventType} event payload`,
-    { eventType, issues, payload },
-    logger7
-  );
-}
-function pushIdentityGuardError(reason, expected, received, logger7) {
-  pushError(
-    "JOIN_FLOW",
-    // Use new error code
-    `Identity guard failed: ${reason}`,
-    { expected, received },
-    logger7
-  );
-}
-function pushLiveKitConnectError(message, error, logger7) {
-  pushError(
-    "LIVEKIT_CONNECT",
-    `LiveKit connection failed: ${message}`,
-    { originalError: error },
-    logger7
-  );
-}
-function pushStaleEventError(eventType, reason, context, logger7) {
-  pushError(
-    "JOIN_FLOW",
-    // Use new error code
-    `Ignored stale ${eventType} event: ${reason}`,
-    context,
-    logger7
-  );
-}
-function pushApiError(operation, error, logger7) {
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  pushError(
-    "API_ERROR",
-    `API ${operation} failed: ${errorMessage}`,
-    { operation, originalError: error },
-    logger7
-  );
-}
-function pushNetworkError(operation, error, logger7) {
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  pushError(
-    "NETWORK",
-    `Network error during ${operation}: ${errorMessage}`,
-    { operation, originalError: error },
-    logger7
-  );
-}
-function pushMediaPermissionError(device, error, logger7) {
-  pushError(
-    "MEDIA_PERMISSION",
-    `${device} permission denied`,
-    { device, originalError: error },
-    logger7
-  );
-}
-function pushDeviceError(operation, device, error, logger7) {
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  pushError(
-    "DEVICE_SWITCH",
-    `Failed to ${operation} ${device}: ${errorMessage}`,
-    { operation, device, originalError: error },
-    logger7
-  );
-}
+// src/core/events/types.ts
+var SdkEventType = /* @__PURE__ */ ((SdkEventType2) => {
+  SdkEventType2["CALL_INITIATED"] = "call:initiated";
+  SdkEventType2["CALL_INCOMING"] = "call:incoming";
+  SdkEventType2["CALL_DECLINED"] = "call:declined";
+  SdkEventType2["CALL_ENDED"] = "call:ended";
+  SdkEventType2["CALL_CANCELED"] = "call:canceled";
+  SdkEventType2["CALL_TIMEOUT"] = "call:timeout";
+  SdkEventType2["CALL_MISSED"] = "call:missed";
+  SdkEventType2["JOIN_INFO_RECEIVED"] = "join-info:received";
+  SdkEventType2["CALL_STARTED"] = "call:started";
+  SdkEventType2["MEETING_CREATED"] = "meeting:created";
+  SdkEventType2["MEETING_STARTED"] = "meeting:started";
+  SdkEventType2["MEETING_JOINED"] = "meeting:joined";
+  SdkEventType2["MEETING_ENDED"] = "meeting:ended";
+  SdkEventType2["PARTICIPANT_UPDATED"] = "participant:updated";
+  SdkEventType2["PARTICIPANT_INVITED"] = "participant:invited";
+  SdkEventType2["RECORDING_STARTED"] = "recording:started";
+  SdkEventType2["RECORDING_STOPPED"] = "recording:stopped";
+  SdkEventType2["GUEST_JOINED"] = "guest:joined";
+  SdkEventType2["GUEST_LEFT"] = "guest:left";
+  SdkEventType2["GUEST_KICKED"] = "guest:kicked";
+  SdkEventType2["GUEST_SESSION_ERROR"] = "guest:session_error";
+  return SdkEventType2;
+})(SdkEventType || {});
 
 // src/clients/signal/services/users.ts
 var SignalUsersService = class {
@@ -2152,63 +1783,473 @@ var useRecordingStore = create()(
   }))
 );
 var recordingStore = useRecordingStore;
-var EventBus = class {
-  constructor() {
-    this.emitter = mitt();
-  }
-  on(eventType, handler) {
-    const wrappedHandler = (event) => {
-      handler(event);
-    };
-    this.emitter.on(eventType.toString(), wrappedHandler);
-    return {
-      unsubscribe: () => {
-        this.emitter.off(eventType.toString(), wrappedHandler);
-      }
+
+// src/utils/session-cleanup.ts
+function cleanupSession() {
+  rtcStore.getState().reset();
+  profileCache.getState().clear();
+  recordingStore.getState().clear();
+  useChatStore.getState().clearChat();
+  useSpotlightStore.getState().clear();
+  useRaiseHandStore.getState().clear();
+}
+
+// src/utils/error-handler.ts
+function handleServiceError(code, defaultMessage, error) {
+  rtcStore.getState().addError({
+    code,
+    message: error.message || defaultMessage,
+    timestamp: Date.now(),
+    context: error
+  });
+  throw error;
+}
+
+// src/utils/session-state.ts
+function setOptimisticSession(partial) {
+  rtcStore.getState().patch((state) => {
+    state.session = {
+      id: "temp",
+      status: "initializing",
+      mode: "VIDEO",
+      ...partial
     };
+  });
+}
+function clearOptimisticSession(clearInitiated = true) {
+  rtcStore.getState().patch((state) => {
+    state.session = null;
+    if (clearInitiated) {
+      state.initiated = false;
+    }
+  });
+}
+
+// src/clients/signal/config.ts
+var logger = createLogger("api-config");
+var OpenApiConfigService = class _OpenApiConfigService {
+  constructor() {
+    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) {
+        logger.debug("API Request with Authorization header", {
+          hasAuth: true,
+          authPrefix: `${authHeader.substring(0, 20)}...`
+        });
+      } else {
+        logger.warn("API Request WITHOUT Authorization header", {
+          hasAuth: false
+        });
+      }
+      return request2;
+    });
   }
-  emit(eventType, payload) {
-    const event = {
-      type: eventType.toString(),
-      payload,
-      timestamp: Date.now()
-    };
-    this.emitter.emit(eventType.toString(), event);
-  }
-  off(eventType) {
-    this.emitter.off(eventType.toString());
+  static getInstance() {
+    if (!_OpenApiConfigService.instance) {
+      _OpenApiConfigService.instance = new _OpenApiConfigService();
+    }
+    return _OpenApiConfigService.instance;
   }
-  removeAllListeners() {
-    this.emitter.all.clear();
+  configure(config) {
+    OpenAPI.BASE = config.baseUrl;
+    if (typeof config.token === "function") {
+      const tokenFn = config.token;
+      OpenAPI.TOKEN = async (_options) => {
+        const result = tokenFn();
+        const token = typeof result === "string" ? result : await result;
+        if (!token) {
+          logger.warn("Token provider returned empty token");
+        } else {
+          logger.debug("Token resolved successfully", {
+            tokenPrefix: `${token.substring(0, 10)}...`
+          });
+        }
+        return token;
+      };
+    } else {
+      OpenAPI.TOKEN = config.token;
+    }
+    OpenAPI.CREDENTIALS = config.credentials ?? "include";
+    OpenAPI.WITH_CREDENTIALS = config.withCredentials ?? false;
+    if (config.headers) {
+      OpenAPI.HEADERS = config.headers;
+    }
+    logger.info("Signal svc configuration completed", {
+      baseUrl: config.baseUrl,
+      hasToken: !!config.token
+    });
   }
 };
-var eventBus = new EventBus();
+var apiConfig = OpenApiConfigService.getInstance();
+
+// src/core/session-storage.ts
+var SessionStorage = class {
+  constructor(key) {
+    this.key = key;
+  }
+  set(data) {
+    const serialized = JSON.stringify(data);
+    sessionStorage.setItem(this.key, serialized);
+  }
+  get() {
+    const stored = sessionStorage.getItem(this.key);
+    if (!stored) {
+      return null;
+    }
+    try {
+      return JSON.parse(stored);
+    } catch {
+      return null;
+    }
+  }
+  clear() {
+    sessionStorage.removeItem(this.key);
+  }
+  exists() {
+    return sessionStorage.getItem(this.key) !== null;
+  }
+};
+
+// src/core/auth.manager.ts
+var logger2 = createLogger("auth-manager");
+var DEFAULT_AUTH_RETRY_CONFIG = {
+  maxRetries: 10,
+  initialDelayMs: 200,
+  maxDelayMs: 5e3,
+  backoffMultiplier: 2
+};
+var AuthManager = class {
+  constructor(authProvider, appId, retryConfig) {
+    this.lastToken = null;
+    this.initializePromise = null;
+    this.authProvider = authProvider;
+    this.appId = appId;
+    this.sessionStorage = new SessionStorage(
+      "callpad_session_info"
+    );
+    this.retryConfig = { ...DEFAULT_AUTH_RETRY_CONFIG, ...retryConfig };
+  }
+  async acquireTokenWithRetry() {
+    const { maxRetries, initialDelayMs, maxDelayMs, backoffMultiplier } = this.retryConfig;
+    let delay = initialDelayMs;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const token = this.authProvider();
+      if (token) {
+        if (attempt > 0) {
+          logger2.debug("Token acquired after retry", { attempt });
+        }
+        return token;
+      }
+      if (attempt < maxRetries) {
+        logger2.debug("Auth token not available, retrying", {
+          attempt: attempt + 1,
+          maxRetries,
+          delayMs: delay
+        });
+        await new Promise((resolve2) => setTimeout(resolve2, delay));
+        delay = Math.min(delay * backoffMultiplier, maxDelayMs);
+      }
+    }
+    throw new Error(
+      `No authentication token available after ${maxRetries} retries. This may indicate the auth provider is temporarily unavailable (e.g., token refresh in progress).`
+    );
+  }
+  async initialize(appId) {
+    try {
+      const token = await this.acquireTokenWithRetry();
+      const originalToken = OpenAPI.TOKEN;
+      OpenAPI.TOKEN = token;
+      try {
+        logger2.debug("Initializing session", { appId });
+        const response = await InitService.getSignalInit({ appId });
+        const sessionInfo = {
+          sessionToken: response.sessionToken,
+          sessionId: response.sessionId,
+          userId: response.userId,
+          deviceId: response.deviceId,
+          expiresAt: response.expiresAt
+        };
+        this.sessionStorage.set(sessionInfo);
+        logger2.info("Session initialized successfully", {
+          sessionId: sessionInfo.sessionId,
+          userId: sessionInfo.userId
+        });
+      } finally {
+        OpenAPI.TOKEN = originalToken;
+      }
+    } catch (error) {
+      logger2.error("Failed to initialize session", { appId, error });
+      throw new Error(`Session initialization failed: ${error}`);
+    }
+  }
+  async getSessionToken() {
+    const sessionInfo = this.sessionStorage.get();
+    if (sessionInfo) {
+      return sessionInfo.sessionToken;
+    }
+    if (!this.initializePromise) {
+      this.initializePromise = this.initialize(this.appId);
+    }
+    try {
+      await this.initializePromise;
+      const newSessionInfo = this.sessionStorage.get();
+      return newSessionInfo?.sessionToken || null;
+    } catch (error) {
+      logger2.error("Failed to get session token", { error });
+      return null;
+    }
+  }
+  getSessionInfo() {
+    return this.sessionStorage.get();
+  }
+  getCurrentToken() {
+    const token = this.authProvider();
+    if (token !== this.lastToken) {
+      this.lastToken = token;
+    }
+    return token;
+  }
+};
+
+// src/core/guest-auth.manager.ts
+var GuestAuthManager = class {
+  constructor(appId, deviceId) {
+    this.appId = appId;
+    this.deviceId = deviceId;
+    this.sessionStorage = new SessionStorage(
+      "callpad_guest_session"
+    );
+  }
+  getAppId() {
+    return this.appId;
+  }
+  getDeviceId() {
+    return this.deviceId;
+  }
+  setSession(session) {
+    this.sessionStorage.set(session);
+  }
+  async getSessionToken() {
+    return this.sessionStorage.get()?.sessionToken || null;
+  }
+  getSessionInfo() {
+    return this.sessionStorage.get();
+  }
+  clearSession() {
+    this.sessionStorage.clear();
+  }
+};
+
+// src/core/socketio/handlers/base.handler.ts
+var BaseSocketHandler = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  get logger() {
+    if (!this._logger) {
+      this._logger = createLogger(`socketio:${this.eventName}`);
+    }
+    return this._logger;
+  }
+  async handleRaw(rawData) {
+    this.logger.info(`${this.eventName} received`, rawData);
+    try {
+      await this.handle(JSON.parse(JSON.stringify(rawData)));
+      this.logger.debug(`${this.eventName} handled successfully`);
+    } catch (error) {
+      this.logger.error(`${this.eventName} handler error`, error);
+      throw error;
+    }
+  }
+  updateStore(updater) {
+    rtcStore.getState().patch(updater);
+  }
+  get livekit() {
+    return this.options.livekit;
+  }
+};
+var callEndedSchema = z.object({
+  callId: z.string(),
+  endedAt: z.string(),
+  endedByUserId: z.string().optional()
+}).strict();
+var callInviteSchema = z.object({
+  inviteId: z.string(),
+  callId: z.string(),
+  userId: z.string(),
+  callerId: z.string(),
+  mode: z.enum(["VIDEO", "AUDIO"]),
+  invitedAt: z.string()
+}).strict();
+var callInviteAcceptedSchema = z.object({
+  callId: z.string(),
+  userId: z.string(),
+  acceptedAt: z.string()
+}).strict();
+var callInviteCancelledSchema = z.object({
+  callId: z.string(),
+  cancelledByUserId: z.string(),
+  cancelledAt: z.string(),
+  reason: z.string()
+}).strict();
+var callInviteDeclinedSchema = z.object({
+  callId: z.string(),
+  userId: z.string(),
+  reason: z.string().optional(),
+  declinedAt: z.string()
+}).strict();
+var callInviteMissedSchema = z.object({
+  callId: z.string(),
+  userId: z.string(),
+  missedAt: z.string()
+}).strict();
+var callParticipantAddedSchema = z.object({
+  callId: z.string(),
+  userId: z.string(),
+  participantId: z.string()
+}).strict();
+var callParticipantKickedSchema = z.object({
+  callId: z.string(),
+  participantId: z.string(),
+  userId: z.string(),
+  reason: z.string().optional()
+}).strict();
+var callParticipantLeftSchema = z.object({
+  callId: z.string(),
+  userId: z.string(),
+  participantId: z.string(),
+  leftAt: z.string(),
+  reason: z.string().optional()
+}).strict();
+var callReadySchema = z.object({
+  callId: z.string(),
+  participantId: z.string().optional(),
+  userId: z.string(),
+  message: z.string()
+}).strict();
+var callRecordingStartedSchema = z.object({
+  callId: z.string(),
+  recordingId: z.string(),
+  egressId: z.string(),
+  initiatedBy: z.string().optional(),
+  startedAt: z.string()
+}).strict();
+var callRecordingStoppedSchema = z.object({
+  callId: z.string(),
+  recordingId: z.string(),
+  egressId: z.string(),
+  stoppedAt: z.string()
+}).strict();
+var callStartedSchema = z.object({
+  callId: z.string(),
+  startedAt: z.string()
+}).strict();
+var participantProfilesSchema = z.object({
+  profiles: z.array(z.object({
+    userId: z.string(),
+    username: z.string().nullable(),
+    firstName: z.string().nullable(),
+    lastName: z.string().nullable(),
+    profilePhoto: z.string().nullable()
+  }).strict())
+}).strict();
+var presencePingSchema = z.object({}).strict();
 
-// src/core/events/types.ts
-var SdkEventType = /* @__PURE__ */ ((SdkEventType2) => {
-  SdkEventType2["CALL_INITIATED"] = "call:initiated";
-  SdkEventType2["CALL_INCOMING"] = "call:incoming";
-  SdkEventType2["CALL_DECLINED"] = "call:declined";
-  SdkEventType2["CALL_ENDED"] = "call:ended";
-  SdkEventType2["CALL_CANCELED"] = "call:canceled";
-  SdkEventType2["CALL_TIMEOUT"] = "call:timeout";
-  SdkEventType2["CALL_MISSED"] = "call:missed";
-  SdkEventType2["JOIN_INFO_RECEIVED"] = "join-info:received";
-  SdkEventType2["CALL_STARTED"] = "call:started";
-  SdkEventType2["MEETING_CREATED"] = "meeting:created";
-  SdkEventType2["MEETING_STARTED"] = "meeting:started";
-  SdkEventType2["MEETING_JOINED"] = "meeting:joined";
-  SdkEventType2["MEETING_ENDED"] = "meeting:ended";
-  SdkEventType2["PARTICIPANT_UPDATED"] = "participant:updated";
-  SdkEventType2["PARTICIPANT_INVITED"] = "participant:invited";
-  SdkEventType2["RECORDING_STARTED"] = "recording:started";
-  SdkEventType2["RECORDING_STOPPED"] = "recording:stopped";
-  SdkEventType2["GUEST_JOINED"] = "guest:joined";
-  SdkEventType2["GUEST_LEFT"] = "guest:left";
-  SdkEventType2["GUEST_KICKED"] = "guest:kicked";
-  SdkEventType2["GUEST_SESSION_ERROR"] = "guest:session_error";
-  return SdkEventType2;
-})(SdkEventType || {});
+// src/state/errors.ts
+function pushError(code, message, context, logger7) {
+  const error = {
+    code,
+    message,
+    timestamp: Date.now(),
+    context
+  };
+  logger7?.("error", message, { code, context });
+  rtcStore.getState().addError(error);
+}
+function clearErrors(predicate) {
+  rtcStore.getState().patch((state) => {
+    if (predicate) {
+      state.errors = state.errors.filter((error) => !predicate(error));
+    } else {
+      state.errors = [];
+    }
+  });
+}
+function pushSocketValidationError(eventType, issues, payload, logger7) {
+  pushError(
+    "SOCKET_PAYLOAD",
+    `Invalid ${eventType} event payload`,
+    { eventType, issues, payload },
+    logger7
+  );
+}
+function pushIdentityGuardError(reason, expected, received, logger7) {
+  pushError(
+    "JOIN_FLOW",
+    // Use new error code
+    `Identity guard failed: ${reason}`,
+    { expected, received },
+    logger7
+  );
+}
+function pushLiveKitConnectError(message, error, logger7) {
+  pushError(
+    "LIVEKIT_CONNECT",
+    `LiveKit connection failed: ${message}`,
+    { originalError: error },
+    logger7
+  );
+}
+function pushStaleEventError(eventType, reason, context, logger7) {
+  pushError(
+    "JOIN_FLOW",
+    // Use new error code
+    `Ignored stale ${eventType} event: ${reason}`,
+    context,
+    logger7
+  );
+}
+function pushApiError(operation, error, logger7) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  pushError(
+    "API_ERROR",
+    `API ${operation} failed: ${errorMessage}`,
+    { operation, originalError: error },
+    logger7
+  );
+}
+function pushNetworkError(operation, error, logger7) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  pushError(
+    "NETWORK",
+    `Network error during ${operation}: ${errorMessage}`,
+    { operation, originalError: error },
+    logger7
+  );
+}
+function pushMediaPermissionError(device, error, logger7) {
+  pushError(
+    "MEDIA_PERMISSION",
+    `${device} permission denied`,
+    { device, originalError: error },
+    logger7
+  );
+}
+function pushDeviceError(operation, device, error, logger7) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  pushError(
+    "DEVICE_SWITCH",
+    `Failed to ${operation} ${device}: ${errorMessage}`,
+    { operation, device, originalError: error },
+    logger7
+  );
+}
 
 // src/core/socketio/handlers/call-ended.handler.ts
 var SessionEndedHandler = class extends BaseSocketHandler {
@@ -3141,13 +3182,11 @@ function createCallsService(config, deps) {
     try {
       console.log(params, "params");
       if (!params.callId) {
+        setOptimisticSession({
+          mode: params.mode || "AUDIO",
+          role: "HOST"
+        });
         rtcStore.getState().patch((state) => {
-          state.session = {
-            id: "temp",
-            status: "initializing",
-            mode: params.mode || "AUDIO",
-            role: "HOST"
-          };
           state.initiated = true;
         });
         console.log("state: ", rtcStore.getState());
@@ -3249,17 +3288,8 @@ function createCallsService(config, deps) {
       });
       return response;
     } catch (error) {
-      rtcStore.getState().patch((state) => {
-        state.session = null;
-        state.initiated = false;
-      });
-      rtcStore.getState().addError({
-        code: "INITIATE_FAILED",
-        message: error.message || "Failed to initiate call",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      clearOptimisticSession();
+      handleServiceError("INITIATE_FAILED", "Failed to initiate call", error);
     }
   }
   async function accept() {
@@ -3268,13 +3298,12 @@ function createCallsService(config, deps) {
       throw new Error("No incoming invite to accept");
     }
     const { callId, inviteId, mode } = currentState.incomingInvite;
+    setOptimisticSession({
+      id: callId,
+      mode,
+      role: "PARTICIPANT"
+    });
     rtcStore.getState().patch((state) => {
-      state.session = {
-        id: callId,
-        status: "initializing",
-        mode,
-        role: "PARTICIPANT"
-      };
       state.incomingInvite = null;
     });
     try {
@@ -3310,13 +3339,7 @@ function createCallsService(config, deps) {
         state.session = null;
         state.incomingInvite = currentState.incomingInvite;
       });
-      rtcStore.getState().addError({
-        code: "ACCEPT_FAILED",
-        message: error.message || "Failed to accept call",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("ACCEPT_FAILED", "Failed to accept call", error);
     }
   }
   async function decline(reason) {
@@ -3342,13 +3365,7 @@ function createCallsService(config, deps) {
       });
       return response;
     } catch (error) {
-      rtcStore.getState().addError({
-        code: "DECLINE_FAILED",
-        message: error.message || "Failed to decline call",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("DECLINE_FAILED", "Failed to decline call", error);
     }
   }
   async function cancel(callId) {
@@ -3358,13 +3375,7 @@ function createCallsService(config, deps) {
         callId
       });
     } catch (error) {
-      rtcStore.getState().addError({
-        code: "CANCEL_FAILED",
-        message: error.message || "Failed to cancel call",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("CANCEL_FAILED", "Failed to cancel call", error);
     }
   }
   async function leave() {
@@ -3372,21 +3383,10 @@ function createCallsService(config, deps) {
       if (deps?.livekitManager) {
         await deps.livekitManager.disconnect();
       } else {
-        rtcStore.getState().reset();
-        profileCache.getState().clear();
-        recordingStore.getState().clear();
-        useChatStore.getState().clearChat();
-        useSpotlightStore.getState().clear();
-        useRaiseHandStore.getState().clear();
+        cleanupSession();
       }
     } catch (error) {
-      rtcStore.getState().addError({
-        code: "LEAVE_FAILED",
-        message: error.message || "Failed to leave call",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("LEAVE_FAILED", "Failed to leave call", error);
     }
   }
   async function transfer(callId, targetParticipantId, reason) {
@@ -3402,13 +3402,7 @@ function createCallsService(config, deps) {
         requestBody
       });
     } catch (error) {
-      rtcStore.getState().addError({
-        code: "TRANSFER_FAILED",
-        message: error.message || "Failed to transfer call",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("TRANSFER_FAILED", "Failed to transfer call", error);
     }
   }
   async function kick(callId, participantId, reason) {
@@ -3424,13 +3418,7 @@ function createCallsService(config, deps) {
         requestBody
       });
     } catch (error) {
-      rtcStore.getState().addError({
-        code: "KICK_FAILED",
-        message: error.message || "Failed to kick participant",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("KICK_FAILED", "Failed to kick participant", error);
     }
   }
   async function mute(callId, participantId) {
@@ -3442,13 +3430,7 @@ function createCallsService(config, deps) {
         }
       });
     } catch (error) {
-      rtcStore.getState().addError({
-        code: "MUTE_FAILED",
-        message: error.message || "Failed to mute participant",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("MUTE_FAILED", "Failed to mute participant", error);
     }
   }
   async function end(callId) {
@@ -3456,21 +3438,10 @@ function createCallsService(config, deps) {
       const response = await signalCalls.end({
         callId
       });
-      rtcStore.getState().reset();
-      profileCache.getState().clear();
-      recordingStore.getState().clear();
-      useChatStore.getState().clearChat();
-      useSpotlightStore.getState().clear();
-      useRaiseHandStore.getState().clear();
+      cleanupSession();
       return response;
     } catch (error) {
-      rtcStore.getState().addError({
-        code: "END_CALL_FAILED",
-        message: error.message || "Failed to end call",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("END_CALL_FAILED", "Failed to end call", error);
     }
   }
   async function invite(callId, invitees) {
@@ -3519,13 +3490,7 @@ function createCallsService(config, deps) {
       });
       return response;
     } catch (error) {
-      rtcStore.getState().addError({
-        code: "INVITE_FAILED",
-        message: error.message || "Failed to send invites",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("INVITE_FAILED", "Failed to send invites", error);
     }
   }
   async function startRecording(callId) {
@@ -3566,13 +3531,7 @@ function createCallsService(config, deps) {
       });
       return response;
     } catch (error) {
-      rtcStore.getState().addError({
-        code: "START_RECORDING_FAILED",
-        message: error.message || "Failed to start recording",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("START_RECORDING_FAILED", "Failed to start recording", error);
     }
   }
   async function stopRecording(callId, recordingId) {
@@ -3589,13 +3548,7 @@ function createCallsService(config, deps) {
       recordingStore.getState().clear();
       return response;
     } catch (error) {
-      rtcStore.getState().addError({
-        code: "STOP_RECORDING_FAILED",
-        message: error.message || "Failed to stop recording",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("STOP_RECORDING_FAILED", "Failed to stop recording", error);
     }
   }
   return {
@@ -3693,14 +3646,12 @@ function createMeetingsService(config, deps) {
   const signalMeetings = new SignalMeetingsService(appId);
   async function createAdHoc(params = {}) {
     try {
+      setOptimisticSession({
+        mode: params.mode || "VIDEO",
+        role: "HOST",
+        sessionType: "MEETING"
+      });
       rtcStore.getState().patch((state) => {
-        state.session = {
-          id: "temp",
-          status: "initializing",
-          mode: params.mode || "VIDEO",
-          role: "HOST",
-          sessionType: "MEETING"
-        };
         state.initiated = true;
       });
       const requestBody = {};
@@ -3734,29 +3685,18 @@ function createMeetingsService(config, deps) {
       });
       return response;
     } catch (error) {
-      rtcStore.getState().patch((state) => {
-        state.session = null;
-        state.initiated = false;
-      });
-      rtcStore.getState().addError({
-        code: "CREATE_MEETING_FAILED",
-        message: error.message || "Failed to create meeting",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      clearOptimisticSession();
+      handleServiceError("CREATE_MEETING_FAILED", "Failed to create meeting", error);
     }
   }
   async function start(meetingId) {
     try {
+      setOptimisticSession({
+        mode: "VIDEO",
+        role: "HOST",
+        sessionType: "MEETING"
+      });
       rtcStore.getState().patch((state) => {
-        state.session = {
-          id: "temp",
-          status: "initializing",
-          mode: "VIDEO",
-          role: "HOST",
-          sessionType: "MEETING"
-        };
         state.initiated = true;
       });
       const response = await signalMeetings.start({
@@ -3783,17 +3723,8 @@ function createMeetingsService(config, deps) {
       });
       return response;
     } catch (error) {
-      rtcStore.getState().patch((state) => {
-        state.session = null;
-        state.initiated = false;
-      });
-      rtcStore.getState().addError({
-        code: "START_MEETING_FAILED",
-        message: error.message || "Failed to start meeting",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      clearOptimisticSession();
+      handleServiceError("START_MEETING_FAILED", "Failed to start meeting", error);
     }
   }
   async function join(params) {
@@ -3801,14 +3732,12 @@ function createMeetingsService(config, deps) {
       throw new Error("Either meetingCode or meetingId is required");
     }
     try {
+      setOptimisticSession({
+        mode: "VIDEO",
+        role: "PARTICIPANT",
+        sessionType: "MEETING"
+      });
       rtcStore.getState().patch((state) => {
-        state.session = {
-          id: "temp",
-          status: "initializing",
-          mode: "VIDEO",
-          role: "PARTICIPANT",
-          sessionType: "MEETING"
-        };
         state.initiated = false;
       });
       const requestBody = {};
@@ -3841,16 +3770,8 @@ function createMeetingsService(config, deps) {
       });
       return response;
     } catch (error) {
-      rtcStore.getState().patch((state) => {
-        state.session = null;
-      });
-      rtcStore.getState().addError({
-        code: "JOIN_MEETING_FAILED",
-        message: error.message || "Failed to join meeting",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      clearOptimisticSession(false);
+      handleServiceError("JOIN_MEETING_FAILED", "Failed to join meeting", error);
     }
   }
   async function end(meetingId) {
@@ -3858,34 +3779,21 @@ function createMeetingsService(config, deps) {
       const response = await signalMeetings.end({
         meetingId
       });
-      rtcStore.getState().reset();
-      profileCache.getState().clear();
-      recordingStore.getState().clear();
-      useChatStore.getState().clearChat();
-      useSpotlightStore.getState().clear();
-      useRaiseHandStore.getState().clear();
+      cleanupSession();
       return response;
     } catch (error) {
-      rtcStore.getState().addError({
-        code: "END_MEETING_FAILED",
-        message: error.message || "Failed to end meeting",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("END_MEETING_FAILED", "Failed to end meeting", error);
     }
   }
   async function guestJoin(params, context) {
     const { meetingCode, displayName, passcode } = params;
+    setOptimisticSession({
+      mode: "VIDEO",
+      role: "GUEST",
+      sessionType: "MEETING"
+    });
     rtcStore.getState().patch((state) => {
       state.isGuestMode = true;
-      state.session = {
-        id: "temp",
-        status: "initializing",
-        mode: "VIDEO",
-        role: "GUEST",
-        sessionType: "MEETING"
-      };
     });
     try {
       const guestJoinParams = {
@@ -3936,13 +3844,7 @@ function createMeetingsService(config, deps) {
         state.guestIdentity = null;
         state.isGuestMode = false;
       });
-      rtcStore.getState().addError({
-        code: "GUEST_JOIN_FAILED",
-        message: error.message || "Failed to join meeting as guest",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("GUEST_JOIN_FAILED", "Failed to join meeting as guest", error);
     }
   }
   async function leave() {
@@ -3952,31 +3854,19 @@ function createMeetingsService(config, deps) {
       if (deps?.livekitManager) {
         await deps.livekitManager.disconnect();
       }
-      rtcStore.getState().patch((state2) => {
-        state2.session = null;
-        state2.initiated = false;
-        if (isGuest) {
+      if (isGuest) {
+        rtcStore.getState().patch((state2) => {
           state2.guestIdentity = null;
           state2.isGuestMode = false;
-        }
-      });
-      profileCache.getState().clear();
-      recordingStore.getState().clear();
-      useChatStore.getState().clearChat();
-      useSpotlightStore.getState().clear();
-      useRaiseHandStore.getState().clear();
+        });
+      }
+      cleanupSession();
       eventBus.emit(
         isGuest ? "guest:left" /* GUEST_LEFT */ : "meeting:ended" /* MEETING_ENDED */,
         {}
       );
     } catch (error) {
-      rtcStore.getState().addError({
-        code: "LEAVE_MEETING_FAILED",
-        message: error.message || "Failed to leave meeting",
-        timestamp: Date.now(),
-        context: error
-      });
-      throw error;
+      handleServiceError("LEAVE_MEETING_FAILED", "Failed to leave meeting", error);
     }
   }
   return {