callway 1.0.0

package/dist/index.js

@@ -0,0 +1,726 @@
+// src/core/PeerManager.ts
+var PeerManager = class {
+  // Multi-peer support: Map of remote peer IDs to their connections
+  peerConnections = /* @__PURE__ */ new Map();
+  // Legacy 1:1 support (for backward compatibility)
+  peerConnection = null;
+  remoteId = null;
+  localId;
+  signalingHandler = null;
+  signalingAdapter = null;
+  registeredInAdapter = false;
+  config;
+  remoteStreamCallback = null;
+  connectionStateCallback = null;
+  iceConnectionStateCallback = null;
+  constructor(localId, config = {}) {
+    this.localId = localId;
+    this.config = config;
+  }
+  /**
+   * Set the signaling handler for sending messages
+   */
+  setSignalingHandler(handler) {
+    this.signalingHandler = handler;
+  }
+  /**
+   * Set a signaling adapter. This will register this peer and wire sending.
+   */
+  setSignalingAdapter(adapter, roomId) {
+    this.signalingAdapter = adapter;
+    this.signalingHandler = async (message) => {
+      await adapter.sendMessage(message);
+    };
+    adapter.registerPeer(this.localId, async (message) => {
+      if (message.type === "offer") {
+        await this.handleOffer(message.data, message.from);
+      } else if (message.type === "answer") {
+        await this.handleAnswer(message.data, message.from);
+      } else if (message.type === "ice-candidate") {
+        await this.addIceCandidate(message.data, message.from);
+      }
+    }, roomId);
+    this.registeredInAdapter = true;
+  }
+  /**
+   * Create a new peer connection for a specific remote peer
+   */
+  createPeerConnection(remoteId, polite) {
+    const pc = new RTCPeerConnection({
+      iceServers: this.config.iceServers || [
+        { urls: "stun:stun.l.google.com:19302" }
+      ]
+    });
+    pc.onicecandidate = (event) => {
+      if (event.candidate && this.signalingHandler) {
+        console.log(`[PeerManager ${this.localId}] ICE candidate for ${remoteId}:`, event.candidate);
+        this.signalingHandler({
+          type: "ice-candidate",
+          from: this.localId,
+          to: remoteId,
+          data: event.candidate.toJSON()
+        });
+      }
+    };
+    pc.onconnectionstatechange = () => {
+      console.log(`[PeerManager ${this.localId}] Connection state with ${remoteId}:`, pc.connectionState);
+      if (this.connectionStateCallback) {
+        this.connectionStateCallback(pc.connectionState, remoteId);
+      }
+    };
+    pc.oniceconnectionstatechange = () => {
+      console.log(`[PeerManager ${this.localId}] ICE connection state with ${remoteId}:`, pc.iceConnectionState);
+      if (this.iceConnectionStateCallback) {
+        this.iceConnectionStateCallback(pc.iceConnectionState, remoteId);
+      }
+    };
+    pc.ontrack = (event) => {
+      console.log(`[PeerManager ${this.localId}] Remote track received from ${remoteId}:`, event.track.kind);
+      if (this.remoteStreamCallback) {
+        if (event.streams && event.streams[0]) {
+          this.remoteStreamCallback(event.streams[0], remoteId);
+        } else {
+          const stream = new MediaStream([event.track]);
+          this.remoteStreamCallback(stream, remoteId);
+        }
+      }
+    };
+    pc.onnegotiationneeded = async () => {
+      const peerInfo = this.peerConnections.get(remoteId);
+      if (!peerInfo) return;
+      if (peerInfo.makingOffer) return;
+      peerInfo.makingOffer = true;
+      try {
+        if (pc.signalingState !== "stable") {
+          console.log(`[PeerManager ${this.localId}] negotiationneeded aborted (state ${pc.signalingState}) for ${remoteId}`);
+          return;
+        }
+        console.log(`[PeerManager ${this.localId}] negotiationneeded -> creating offer for ${remoteId}`);
+        const offer = await pc.createOffer();
+        await pc.setLocalDescription(offer);
+        peerInfo.isInitiator = true;
+        if (this.signalingHandler) {
+          await this.signalingHandler({
+            type: "offer",
+            from: this.localId,
+            to: remoteId,
+            data: offer
+          });
+        }
+      } catch (err) {
+        console.warn(`[PeerManager ${this.localId}] negotiationneeded failed for ${remoteId}:`, err);
+      } finally {
+        peerInfo.makingOffer = false;
+      }
+    };
+    return pc;
+  }
+  /**
+   * Initialize peer connection for a call (1:1 compatibility)
+   * For multi-peer calls, use addPeer() instead
+   */
+  async initialize(remoteId) {
+    if (this.peerConnection || this.peerConnections.has(remoteId)) {
+      throw new Error("Peer connection already initialized");
+    }
+    this.remoteId = remoteId;
+    const polite = this.localId > remoteId;
+    this.peerConnection = this.createPeerConnection(remoteId, polite);
+    this.peerConnections.set(remoteId, {
+      connection: this.peerConnection,
+      remoteId,
+      isInitiator: false,
+      iceCandidateQueue: [],
+      remoteDescriptionSet: false,
+      makingOffer: false,
+      polite
+    });
+    console.log(`[PeerManager ${this.localId}] Initialized peer connection for remote: ${remoteId}`);
+  }
+  /**
+   * Add a new peer to the room (multi-peer support)
+   * Creates a new RTCPeerConnection for this peer
+   */
+  async addPeer(remoteId, isInitiator = false) {
+    if (this.peerConnections.has(remoteId)) {
+      console.warn(`[PeerManager ${this.localId}] Peer ${remoteId} already exists`);
+      return;
+    }
+    const polite = this.localId > remoteId;
+    const pc = this.createPeerConnection(remoteId, polite);
+    this.peerConnections.set(remoteId, {
+      connection: pc,
+      remoteId,
+      isInitiator,
+      iceCandidateQueue: [],
+      remoteDescriptionSet: false,
+      makingOffer: false,
+      polite
+    });
+    console.log(`[PeerManager ${this.localId}] Added peer: ${remoteId} (initiator: ${isInitiator})`);
+  }
+  /**
+   * Remove a peer from the room
+   */
+  async removePeer(remoteId) {
+    const peerInfo = this.peerConnections.get(remoteId);
+    if (!peerInfo) {
+      console.warn(`[PeerManager ${this.localId}] Peer ${remoteId} not found`);
+      return;
+    }
+    console.log(`[PeerManager ${this.localId}] Removing peer: ${remoteId}`);
+    peerInfo.connection.close();
+    this.peerConnections.delete(remoteId);
+    if (this.remoteId === remoteId) {
+      this.peerConnection = null;
+      this.remoteId = null;
+    }
+  }
+  /**
+   * Get all remote peer IDs
+   */
+  getRemotePeerIds() {
+    return Array.from(this.peerConnections.keys());
+  }
+  /**
+   * Check if a peer exists
+   */
+  hasPeer(remoteId) {
+    return this.peerConnections.has(remoteId);
+  }
+  /**
+   * Get peer connection for a specific remote peer (multi-peer support)
+   */
+  getPeerConnectionFor(remoteId) {
+    return this.peerConnections.get(remoteId)?.connection ?? null;
+  }
+  /**
+   * Create an offer for a specific peer (caller side)
+   */
+  async createOffer(remoteId) {
+    const peerInfo = this.peerConnections.get(remoteId);
+    if (!peerInfo) {
+      throw new Error(`Peer ${remoteId} not found. Call addPeer() first.`);
+    }
+    const pc = peerInfo.connection;
+    console.log(`[PeerManager ${this.localId}] Creating offer for ${remoteId}...`);
+    peerInfo.makingOffer = true;
+    try {
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      peerInfo.isInitiator = true;
+      console.log(`[PeerManager ${this.localId}] Offer created for ${remoteId}:`, offer);
+      if (this.signalingHandler) {
+        await this.signalingHandler({
+          type: "offer",
+          from: this.localId,
+          to: remoteId,
+          data: offer
+        });
+      }
+      return offer;
+    } finally {
+      peerInfo.makingOffer = false;
+    }
+  }
+  /**
+   * Create offers for all peers (multi-peer support)
+   */
+  async createOffersForAll() {
+    const promises = Array.from(this.peerConnections.keys()).map(
+      (remoteId) => this.createOffer(remoteId)
+    );
+    await Promise.all(promises);
+    console.log(`[PeerManager ${this.localId}] Created offers for all ${this.peerConnections.size} peers`);
+  }
+  /**
+   * Handle incoming offer from a peer (callee side)
+   *
+   * Collision strategy: the peer who already has a local offer ignores the
+   * incoming offer (impolite); with deterministic initiator selection in the
+   * caller, collisions should be rare. This keeps the signaling state valid.
+   */
+  async handleOffer(offer, remoteId) {
+    let peerInfo = this.peerConnections.get(remoteId);
+    if (!peerInfo) {
+      await this.addPeer(remoteId, false);
+      peerInfo = this.peerConnections.get(remoteId);
+    }
+    const pc = peerInfo.connection;
+    const collision = peerInfo.makingOffer || pc.signalingState === "have-local-offer";
+    const ignoreOffer = !peerInfo.polite && collision;
+    if (ignoreOffer) {
+      console.log(`[PeerManager ${this.localId}] Ignoring offer from ${remoteId} (collision, impolite)`);
+      return null;
+    }
+    if (collision && peerInfo.polite) {
+      console.log(`[PeerManager ${this.localId}] Offer collision with ${remoteId} (polite) - rolling back and accepting`);
+      try {
+        await pc.setLocalDescription({ type: "rollback" });
+      } catch (err) {
+        console.warn(`[PeerManager ${this.localId}] rollback failed:`, err);
+      }
+    }
+    if (pc.signalingState !== "stable" && pc.signalingState !== "have-local-offer") {
+      console.warn(`[PeerManager ${this.localId}] Cannot handle offer from ${remoteId}, signaling state is ${pc.signalingState}`);
+      return null;
+    }
+    console.log(`[PeerManager ${this.localId}] Handling offer from ${remoteId}...`);
+    try {
+      const currentPc = peerInfo.connection;
+      await currentPc.setRemoteDescription(new RTCSessionDescription(offer));
+      peerInfo.remoteDescriptionSet = true;
+      await this.processIceCandidateQueue(remoteId);
+      const answer = await currentPc.createAnswer();
+      await currentPc.setLocalDescription(answer);
+      peerInfo.isInitiator = false;
+      console.log(`[PeerManager ${this.localId}] Answer created for ${remoteId}:`, answer);
+      if (this.signalingHandler) {
+        await this.signalingHandler({
+          type: "answer",
+          from: this.localId,
+          to: remoteId,
+          data: answer
+        });
+      }
+      return answer;
+    } catch (error) {
+      console.error(`[PeerManager ${this.localId}] Error handling offer from ${remoteId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Handle incoming answer from a peer (caller side)
+   */
+  async handleAnswer(answer, remoteId) {
+    const peerInfo = this.peerConnections.get(remoteId);
+    if (!peerInfo) {
+      throw new Error(`Peer ${remoteId} not found. Call addPeer() first.`);
+    }
+    const pc = peerInfo.connection;
+    if (pc.signalingState !== "have-local-offer") {
+      if (pc.signalingState === "stable") {
+        console.log(`[PeerManager ${this.localId}] Ignoring answer from ${remoteId} - already in stable state`);
+        return;
+      }
+      console.warn(`[PeerManager ${this.localId}] Cannot handle answer from ${remoteId}, signaling state is ${pc.signalingState}`);
+      return;
+    }
+    console.log(`[PeerManager ${this.localId}] Handling answer from ${remoteId}...`);
+    try {
+      await pc.setRemoteDescription(new RTCSessionDescription(answer));
+      peerInfo.remoteDescriptionSet = true;
+      await this.processIceCandidateQueue(remoteId);
+      console.log(`[PeerManager ${this.localId}] Answer processed for ${remoteId}`);
+    } catch (error) {
+      console.error(`[PeerManager ${this.localId}] Error handling answer from ${remoteId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Process queued ICE candidates for a peer
+   */
+  async processIceCandidateQueue(remoteId) {
+    const peerInfo = this.peerConnections.get(remoteId);
+    if (!peerInfo || peerInfo.iceCandidateQueue.length === 0) {
+      return;
+    }
+    const pc = peerInfo.connection;
+    console.log(`[PeerManager ${this.localId}] Processing ${peerInfo.iceCandidateQueue.length} queued ICE candidates for ${remoteId}`);
+    const candidates = [...peerInfo.iceCandidateQueue];
+    peerInfo.iceCandidateQueue = [];
+    for (const candidate of candidates) {
+      try {
+        await pc.addIceCandidate(new RTCIceCandidate(candidate));
+      } catch (error) {
+        console.warn(`[PeerManager ${this.localId}] Failed to add queued ICE candidate for ${remoteId}:`, error);
+      }
+    }
+  }
+  /**
+   * Add ICE candidate for a specific peer
+   * Queues candidates if remote description is not set yet
+   */
+  async addIceCandidate(candidate, remoteId) {
+    const peerInfo = this.peerConnections.get(remoteId);
+    if (!peerInfo) {
+      console.warn(`[PeerManager ${this.localId}] Cannot add ICE candidate: Peer ${remoteId} not found`);
+      return;
+    }
+    const pc = peerInfo.connection;
+    if (!peerInfo.remoteDescriptionSet) {
+      console.log(`[PeerManager ${this.localId}] Queuing ICE candidate for ${remoteId} (remote description not set yet)`);
+      peerInfo.iceCandidateQueue.push(candidate);
+      return;
+    }
+    try {
+      console.log(`[PeerManager ${this.localId}] Adding ICE candidate for ${remoteId}`);
+      await pc.addIceCandidate(new RTCIceCandidate(candidate));
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.message.includes("duplicate") || error.message.includes("already been added")) {
+          console.log(`[PeerManager ${this.localId}] Duplicate ICE candidate for ${remoteId} (ignored)`);
+          return;
+        }
+        if (pc.connectionState === "closed" || pc.connectionState === "failed") {
+          console.warn(`[PeerManager ${this.localId}] Cannot add ICE candidate: connection to ${remoteId} is ${pc.connectionState}`);
+          return;
+        }
+      }
+      console.warn(`[PeerManager ${this.localId}] Failed to add ICE candidate for ${remoteId}:`, error);
+    }
+  }
+  /**
+   * Add a media track to a specific peer connection
+   */
+  addTrack(track, stream, remoteId) {
+    if (remoteId) {
+      const peerInfo = this.peerConnections.get(remoteId);
+      if (!peerInfo) {
+        throw new Error(`Peer ${remoteId} not found. Call addPeer() first.`);
+      }
+      console.log(`[PeerManager ${this.localId}] Adding track to ${remoteId}:`, track.kind);
+      peerInfo.connection.addTrack(track, stream);
+    } else {
+      if (!this.peerConnection) {
+        throw new Error("Peer connection not initialized. Call initialize() first.");
+      }
+      console.log(`[PeerManager ${this.localId}] Adding track:`, track.kind);
+      this.peerConnection.addTrack(track, stream);
+    }
+  }
+  /**
+   * Add media tracks to all peer connections (multi-peer support)
+   */
+  addTrackToAll(track, stream) {
+    this.peerConnections.forEach((peerInfo, remoteId) => {
+      console.log(`[PeerManager ${this.localId}] Adding track to ${remoteId}:`, track.kind);
+      peerInfo.connection.addTrack(track, stream);
+    });
+  }
+  /**
+   * Get the remote media stream for a specific peer
+   */
+  getRemoteStream(remoteId) {
+    const peerInfo = this.peerConnections.get(remoteId);
+    if (!peerInfo) {
+      return null;
+    }
+    const pc = peerInfo.connection;
+    const tracks = [];
+    pc.getReceivers().forEach((receiver) => {
+      if (receiver.track) {
+        tracks.push(receiver.track);
+      }
+    });
+    if (tracks.length === 0) {
+      return null;
+    }
+    return new MediaStream(tracks);
+  }
+  /**
+   * Set handler for when remote stream is available
+   * Callback receives (stream, remoteId) for multi-peer support
+   * Can be called before or after initialization
+   */
+  onRemoteStream(callback) {
+    this.remoteStreamCallback = callback;
+    this.peerConnections.forEach((peerInfo, remoteId) => {
+      peerInfo.connection.ontrack = (event) => {
+        console.log(`[PeerManager ${this.localId}] Remote track received from ${remoteId}:`, event.track.kind);
+        if (event.streams && event.streams[0]) {
+          callback(event.streams[0], remoteId);
+        } else {
+          const stream = new MediaStream([event.track]);
+          callback(stream, remoteId);
+        }
+      };
+    });
+  }
+  /**
+   * Set handler for connection state changes
+   * Callback receives (state, remoteId) for multi-peer support
+   */
+  onConnectionStateChange(callback) {
+    this.connectionStateCallback = callback;
+    this.peerConnections.forEach((peerInfo, remoteId) => {
+      callback(peerInfo.connection.connectionState, remoteId);
+    });
+  }
+  /**
+   * Set handler for ICE connection state changes
+   * Callback receives (state, remoteId) for multi-peer support
+   */
+  onIceConnectionStateChange(callback) {
+    this.iceConnectionStateCallback = callback;
+    this.peerConnections.forEach((peerInfo, remoteId) => {
+      callback(peerInfo.connection.iceConnectionState, remoteId);
+    });
+  }
+  /**
+   * Get the peer connection instance (legacy 1:1 support)
+   */
+  getPeerConnection() {
+    return this.peerConnection;
+  }
+  /**
+   * Cleanup and close all peer connections
+   */
+  async cleanup() {
+    const cleanupPromises = Array.from(this.peerConnections.values()).map((peerInfo) => {
+      console.log(`[PeerManager ${this.localId}] Cleaning up connection to ${peerInfo.remoteId}...`);
+      peerInfo.connection.close();
+    });
+    await Promise.all(cleanupPromises);
+    this.peerConnections.clear();
+    if (this.peerConnection) {
+      this.peerConnection.close();
+      this.peerConnection = null;
+      this.remoteId = null;
+    }
+    if (this.signalingAdapter && this.registeredInAdapter) {
+      this.signalingAdapter.unregisterPeer(this.localId);
+      this.signalingAdapter = null;
+      this.registeredInAdapter = false;
+    }
+    console.log(`[PeerManager ${this.localId}] All connections cleaned up`);
+  }
+};
+
+// src/core/MediaManager.ts
+var MediaManager = class {
+  localStream = null;
+  /**
+   * Request user media (audio and/or video)
+   */
+  async getUserMedia(constraints = { audio: true, video: true }) {
+    console.log("[MediaManager] Requesting user media with constraints:", constraints);
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia(constraints);
+      this.localStream = stream;
+      console.log("[MediaManager] User media obtained:", {
+        audioTracks: stream.getAudioTracks().length,
+        videoTracks: stream.getVideoTracks().length
+      });
+      return stream;
+    } catch (error) {
+      console.error("[MediaManager] Error getting user media:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get the current local stream
+   */
+  getLocalStream() {
+    return this.localStream;
+  }
+  /**
+   * Stop all tracks in the local stream
+   */
+  stopLocalStream() {
+    if (this.localStream) {
+      console.log("[MediaManager] Stopping local stream...");
+      this.localStream.getTracks().forEach((track) => {
+        track.stop();
+        console.log(`[MediaManager] Stopped track: ${track.kind}`);
+      });
+      this.localStream = null;
+    }
+  }
+  /**
+   * Attach local stream to a peer connection (1:1 or specific peer)
+   * This adds all tracks from the local stream to the peer connection
+   */
+  attachToPeer(peerManager, remoteId) {
+    if (!this.localStream) {
+      throw new Error("No local stream available. Call getUserMedia() first.");
+    }
+    console.log(`[MediaManager] Attaching local stream to peer${remoteId ? ` ${remoteId}` : ""}...`);
+    this.localStream.getTracks().forEach((track) => {
+      peerManager.addTrack(track, this.localStream, remoteId);
+    });
+    console.log(`[MediaManager] Local stream attached${remoteId ? ` to ${remoteId}` : ""}`);
+  }
+  /**
+   * Attach local stream to all peers in a room (multi-peer support)
+   * This adds all tracks from the local stream to all peer connections
+   */
+  attachToAllPeers(peerManager) {
+    if (!this.localStream) {
+      throw new Error("No local stream available. Call getUserMedia() first.");
+    }
+    const peerIds = peerManager.getRemotePeerIds();
+    console.log(`[MediaManager] Attaching local stream to ${peerIds.length} peers...`);
+    this.localStream.getTracks().forEach((track) => {
+      peerManager.addTrackToAll(track, this.localStream);
+    });
+    console.log(`[MediaManager] Local stream attached to all peers`);
+  }
+  /**
+   * Check if camera (video) is off/muted
+   * Returns true if camera is off, false if on
+   */
+  isCameraOff() {
+    if (!this.localStream) {
+      return true;
+    }
+    const videoTracks = this.localStream.getVideoTracks();
+    if (videoTracks.length === 0) {
+      return true;
+    }
+    return videoTracks.every((track) => track.muted || !track.enabled || track.readyState === "ended");
+  }
+  /**
+   * Check if microphone (audio) is off/muted
+   * Returns true if microphone is off, false if on
+   */
+  isMicrophoneOff() {
+    if (!this.localStream) {
+      return true;
+    }
+    const audioTracks = this.localStream.getAudioTracks();
+    if (audioTracks.length === 0) {
+      return true;
+    }
+    return audioTracks.every((track) => track.muted || !track.enabled || track.readyState === "ended");
+  }
+  /**
+   * Get camera track state
+   * Returns the first video track or null
+   */
+  getCameraTrack() {
+    if (!this.localStream) {
+      return null;
+    }
+    const videoTracks = this.localStream.getVideoTracks();
+    return videoTracks.length > 0 ? videoTracks[0] : null;
+  }
+  /**
+   * Get microphone track state
+   * Returns the first audio track or null
+   */
+  getMicrophoneTrack() {
+    if (!this.localStream) {
+      return null;
+    }
+    const audioTracks = this.localStream.getAudioTracks();
+    return audioTracks.length > 0 ? audioTracks[0] : null;
+  }
+  /**
+   * Get detailed media state information
+   */
+  getMediaState() {
+    const videoTrack = this.getCameraTrack();
+    const audioTrack = this.getMicrophoneTrack();
+    return {
+      hasStream: this.localStream !== null,
+      camera: {
+        available: videoTrack !== null,
+        enabled: videoTrack?.enabled ?? false,
+        muted: videoTrack?.muted ?? true,
+        readyState: videoTrack?.readyState ?? null
+      },
+      microphone: {
+        available: audioTrack !== null,
+        enabled: audioTrack?.enabled ?? false,
+        muted: audioTrack?.muted ?? true,
+        readyState: audioTrack?.readyState ?? null
+      }
+    };
+  }
+  /**
+   * Cleanup - stop all tracks
+   */
+  cleanup() {
+    this.stopLocalStream();
+  }
+};
+
+// src/core/mediaUtils.ts
+function isCameraOff(stream) {
+  if (!stream) {
+    return true;
+  }
+  const videoTracks = stream.getVideoTracks();
+  if (videoTracks.length === 0) {
+    return true;
+  }
+  return videoTracks.every((track) => track.muted || !track.enabled || track.readyState === "ended");
+}
+function isMicrophoneOff(stream) {
+  if (!stream) {
+    return true;
+  }
+  const audioTracks = stream.getAudioTracks();
+  if (audioTracks.length === 0) {
+    return true;
+  }
+  return audioTracks.every((track) => track.muted || !track.enabled || track.readyState === "ended");
+}
+function getCameraTrack(stream) {
+  if (!stream) {
+    return null;
+  }
+  const videoTracks = stream.getVideoTracks();
+  return videoTracks.length > 0 ? videoTracks[0] : null;
+}
+function getMicrophoneTrack(stream) {
+  if (!stream) {
+    return null;
+  }
+  const audioTracks = stream.getAudioTracks();
+  return audioTracks.length > 0 ? audioTracks[0] : null;
+}
+function getMediaState(stream) {
+  const videoTrack = getCameraTrack(stream);
+  const audioTrack = getMicrophoneTrack(stream);
+  return {
+    hasStream: stream !== null,
+    camera: {
+      available: videoTrack !== null,
+      enabled: videoTrack?.enabled ?? false,
+      muted: videoTrack?.muted ?? true,
+      readyState: videoTrack?.readyState ?? null
+    },
+    microphone: {
+      available: audioTrack !== null,
+      enabled: audioTrack?.enabled ?? false,
+      muted: audioTrack?.muted ?? true,
+      readyState: audioTrack?.readyState ?? null
+    }
+  };
+}
+function observeMediaState(stream, callback) {
+  if (!stream) {
+    callback(getMediaState(null));
+    return () => {
+    };
+  }
+  callback(getMediaState(stream));
+  const trackHandlers = /* @__PURE__ */ new Map();
+  const updateState = () => {
+    callback(getMediaState(stream));
+  };
+  const allTracks = [...stream.getAudioTracks(), ...stream.getVideoTracks()];
+  allTracks.forEach((track) => {
+    const handleMute = () => updateState();
+    const handleUnmute = () => updateState();
+    const handleEnded = () => updateState();
+    track.addEventListener("mute", handleMute);
+    track.addEventListener("unmute", handleUnmute);
+    track.addEventListener("ended", handleEnded);
+    trackHandlers.set(track, () => {
+      track.removeEventListener("mute", handleMute);
+      track.removeEventListener("unmute", handleUnmute);
+      track.removeEventListener("ended", handleEnded);
+    });
+  });
+  return () => {
+    trackHandlers.forEach((cleanup) => cleanup());
+    trackHandlers.clear();
+  };
+}
+
+export { MediaManager, PeerManager, getCameraTrack, getMediaState, getMicrophoneTrack, isCameraOff, isMicrophoneOff, observeMediaState };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map