@encarnage7/local-meet 0.0.0-stage → 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2558 @@
+/**
+ * Local Meet SDK v1.0.0 (CommonJS)
+ * Zero-trust WebRTC P2P Mesh & Cloudflare Calls SFU client library
+ * License: MIT
+ */
+
+/**
+ * Eventos emitidos por LocalMeetRoom
+ */
+const RoomEvents = Object.freeze({
+  ParticipantConnected: "participantConnected",
+  ParticipantDisconnected: "participantDisconnected",
+  ParticipantMetadataChanged: "participantMetadataChanged",
+  ParticipantPermissionsChanged: "participantPermissionsChanged",
+  DataReceived: "dataReceived",
+  TrackSubscribed: "trackSubscribed",
+  TrackUnsubscribed: "trackUnsubscribed",
+  TrackUnpublished: "trackUnpublished",
+  LocalTrackPublished: "localTrackPublished",
+  LocalTrackUnpublished: "localTrackUnpublished",
+  TrackMuted: "trackMuted",
+  TrackUnmuted: "trackUnmuted",
+  ActiveSpeakersChanged: "activeSpeakersChanged",
+  Disconnected: "disconnected",
+  Error: "error",
+});
+
+const TrackSources = Object.freeze({
+  Camera: "camera",
+  Microphone: "microphone",
+  ScreenShare: "screen_share",
+  ScreenShareAudio: "screen_share_audio",
+});
+
+const TrackKinds = Object.freeze({
+  Audio: "audio",
+  Video: "video",
+});
+
+const EngineModes = Object.freeze({
+  CloudflareCalls: "cf-calls",
+  P2PMesh: "p2p",
+  LiveKit: "livekit",
+});
+
+
+/**
+ * Cifrado de paquetes de datos de sala con AES-GCM-256 usando Web Crypto API.
+ */
+
+const PBKDF2_ITERATIONS = 100000;
+const cachedAesKeys = new Map();
+
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+function base64ToBytes(base64) {
+  const binary = atob(base64);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    out[i] = binary.charCodeAt(i);
+  }
+  return out;
+}
+
+async function deriveRoomAesKey(roomHash, extraSecret = "") {
+  const cleanHash = (roomHash || "").toLowerCase().trim();
+  const cacheKey = `${cleanHash}::${extraSecret}`;
+  if (cachedAesKeys.has(cacheKey)) {
+    return cachedAesKeys.get(cacheKey);
+  }
+
+  const salt = new TextEncoder().encode(`local-meet-salt-v1:${cleanHash}`);
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(`${cleanHash}:${extraSecret}`),
+    "PBKDF2",
+    false,
+    ["deriveKey"]
+  );
+
+  const aesKey = await crypto.subtle.deriveKey(
+    {
+      name: "PBKDF2",
+      salt,
+      iterations: PBKDF2_ITERATIONS,
+      hash: "SHA-256",
+    },
+    keyMaterial,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+
+  cachedAesKeys.set(cacheKey, aesKey);
+  return aesKey;
+}
+
+async function encryptDataPacket(roomHash, plaintext, extraSecret = "") {
+  const aesKey = await deriveRoomAesKey(roomHash, extraSecret);
+  const iv = new Uint8Array(12);
+  crypto.getRandomValues(iv);
+  const encoded = new TextEncoder().encode(plaintext);
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    aesKey,
+    encoded
+  );
+  return {
+    e2ee: "aes-gcm-256",
+    iv: bytesToBase64(iv),
+    ct: bytesToBase64(new Uint8Array(ciphertext)),
+  };
+}
+
+async function decryptDataPacket(roomHash, packet, extraSecret = "") {
+  if (!packet || packet.e2ee !== "aes-gcm-256" || !packet.iv || !packet.ct) {
+    return null;
+  }
+  try {
+    const aesKey = await deriveRoomAesKey(roomHash, extraSecret);
+    const iv = base64ToBytes(packet.iv);
+    const ct = base64ToBytes(packet.ct);
+    const decryptedBuffer = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv },
+      aesKey,
+      ct
+    );
+    return new TextDecoder().decode(decryptedBuffer);
+  } catch {
+    return null;
+  }
+}
+
+
+
+
+const DEFAULT_ICE_SERVERS = [
+  { urls: "stun:stun.cloudflare.com:3478" },
+  { urls: "stun:stun.l.google.com:19302" },
+  { urls: "stun:stun1.l.google.com:19302" },
+  {
+    urls: [
+      "turn:openrelay.metered.ca:80",
+      "turn:openrelay.metered.ca:443",
+      "turn:openrelay.metered.ca:443?transport=tcp",
+      "turns:openrelay.metered.ca:443?transport=tcp",
+    ],
+    username: "openrelayproject",
+    credential: "openrelayproject",
+  },
+];
+
+class HybridTrack {
+  constructor(mediaStreamTrack, kind, source) {
+    this.mediaStreamTrack = mediaStreamTrack;
+    this.kind = kind;
+    this.source = source;
+    this.mediaStream = mediaStreamTrack ? new MediaStream([mediaStreamTrack]) : null;
+    this.primaryElement = null;
+    this.attachedElements = new Set();
+  }
+
+  attach(existingElement = null) {
+    if (this.kind === TrackKinds.Video && this.primaryElement) {
+      const el = this.primaryElement;
+      el.autoplay = true;
+      el.playsInline = true;
+      el.muted = true;
+      if (this.mediaStream && el.srcObject !== this.mediaStream) {
+        el.srcObject = this.mediaStream;
+      }
+      this.attachedElements.add(el);
+      return el;
+    }
+
+    const el =
+      existingElement ||
+      document.createElement(this.kind === TrackKinds.Audio ? "audio" : "video");
+    el.autoplay = true;
+    el.playsInline = true;
+    if (this.kind === TrackKinds.Video) {
+      el.muted = true;
+      el.setAttribute("muted", "");
+      el.setAttribute("playsinline", "");
+      el.setAttribute("autoplay", "");
+    }
+    if (this.mediaStream) {
+      el.srcObject = this.mediaStream;
+    }
+    const ensurePlay = () => {
+      el.play?.().catch(() => {});
+    };
+    el.addEventListener("loadedmetadata", ensurePlay);
+    el.addEventListener("loadeddata", ensurePlay);
+    if (this.mediaStreamTrack) {
+      this.mediaStreamTrack.addEventListener("unmute", ensurePlay);
+    }
+    if (this.kind === TrackKinds.Video) {
+      this.primaryElement = el;
+    }
+    this.attachedElements.add(el);
+    return el;
+  }
+
+  detach() {
+    const list = Array.from(this.attachedElements);
+    for (const el of list) {
+      try {
+        el.srcObject = null;
+      } catch {
+        // Ignorar
+      }
+    }
+    this.primaryElement = null;
+    this.attachedElements.clear();
+    return list;
+  }
+
+  stop() {
+    try {
+      this.mediaStreamTrack?.stop();
+    } catch {
+      // Ignorar
+    }
+  }
+}
+
+class HybridPublication {
+  constructor({ trackSid, source, track = null, isMuted = false }) {
+    this.trackSid = trackSid;
+    this.source = source;
+    this.track = track;
+    this.isMuted = isMuted;
+  }
+}
+
+class HybridParticipant {
+  constructor({ identity, name, metadata = "{}", permissions = {}, isLocal = false, room = null }) {
+    this.identity = identity;
+    this.name = name;
+    this.metadata = metadata;
+    this.permissions = {
+      canPublish: Boolean(permissions.canPublish),
+      canSubscribe: Boolean(permissions.canSubscribe),
+      canPublishData: Boolean(permissions.canPublishData),
+    };
+    this.isLocal = isLocal;
+    this.room = room;
+    this.trackPublications = new Map();
+    this.videoTrackPublications = new Map();
+    this.peerId = "";
+    this.cfSessionId = "";
+    this.cfPublishedTracks = [];
+  }
+
+  getTrackPublication(source) {
+    return this.trackPublications.get(source) || null;
+  }
+
+  setPublication(source, publication) {
+    if (!publication) {
+      this.trackPublications.delete(source);
+      this.videoTrackPublications.delete(source);
+      return;
+    }
+    this.trackPublications.set(source, publication);
+    if (source === TrackSources.Camera || source === TrackSources.ScreenShare) {
+      this.videoTrackPublications.set(source, publication);
+    }
+  }
+
+  async enableCameraAndMicrophone() {
+    if (!this.isLocal || !this.room) return;
+    await this.room.enableCameraAndMicrophone();
+  }
+
+  async setMicrophoneEnabled(enabled) {
+    if (!this.isLocal || !this.room) return;
+    await this.room.setMicrophoneEnabled(Boolean(enabled));
+  }
+
+  async setCameraEnabled(enabled) {
+    if (!this.isLocal || !this.room) return;
+    await this.room.setCameraEnabled(Boolean(enabled));
+  }
+
+  async setScreenShareEnabled(enabled) {
+    if (!this.isLocal || !this.room) return null;
+    return this.room.setScreenShareEnabled(Boolean(enabled));
+  }
+
+  async publishData(payloadUint8, options = {}) {
+    if (!this.isLocal || !this.room) return;
+    await this.room.sendData(payloadUint8, options);
+  }
+}
+
+class LocalMeetRoom {
+  constructor(options = {}) {
+    const {
+      serverUrl = typeof window !== "undefined" ? window.location.origin : "",
+      roomHash = "",
+      title = "",
+      identity = "",
+      displayName = "Participante",
+      isHost = false,
+      hostSecret = "",
+      engine = EngineModes.CloudflareCalls,
+      cfCallsReady = false,
+      startInWaitingRoom = false,
+      iceServers = [],
+      debug = false,
+    } = options;
+
+    this.serverUrl = (serverUrl || "").replace(/\/+$/, "");
+    this.roomHash = (roomHash || "").toLowerCase().trim();
+    this.roomTitle = title || `Sala ${this.roomHash}`;
+    this.isHost = Boolean(isHost);
+    this.hostSecret = hostSecret || "";
+    this.engine = engine;
+    this.cfCallsReady = Boolean(cfCallsReady && engine === EngineModes.CloudflareCalls);
+    this.debug = Boolean(debug);
+
+    this.iceServers =
+      Array.isArray(iceServers) && iceServers.length > 0 ? iceServers : DEFAULT_ICE_SERVERS;
+
+    this.listeners = new Map();
+    this.remoteParticipants = new Map();
+
+    const localId = identity || `usr_${Math.random().toString(36).slice(2, 10)}`;
+    this.localParticipant = new HybridParticipant({
+      identity: localId,
+      name: displayName,
+      metadata: JSON.stringify({
+        role: this.isHost ? "host" : "guest",
+        status: startInWaitingRoom ? "waiting" : "approved",
+        room_title: this.roomTitle,
+      }),
+      permissions: {
+        canPublish: !startInWaitingRoom,
+        canSubscribe: !startInWaitingRoom,
+        canPublishData: !startInWaitingRoom,
+      },
+      isLocal: true,
+      room: this,
+    });
+
+    this.peer = null;
+    this.hostConn = null;
+    this.knownHostPeerId = this.getHostPeerId();
+    this.guestConns = new Map();
+    this.activeMediaCalls = new Map();
+    this.directScreenPcs = new Map();
+    this.incomingScreenPcs = new Map();
+    this.pendingScreenIce = new Map();
+    this.rtcSignalQueues = new Map();
+
+    this.joinedAt = Date.now();
+    this.outgoingHttpSignals = [];
+    this.processedSignalIds = new Set();
+    this.syncTimer = null;
+    this.peerKeepAliveTimer = null;
+    this.syncInFlight = false;
+
+    // Estado Cloudflare Calls SFU
+    this.cfSessionId = "";
+    this.cfPc = null;
+    this.cfInitPromise = null;
+    this.cfTransceivers = new Map();
+    this.cfPulledRemoteKeys = new Set();
+    this.cfPullRetryCounts = new Map();
+    this.cfMidToRemoteMeta = new Map();
+    this.cfNegotiationChain = Promise.resolve();
+    this.currentScreenTrackName = "screen";
+    this.isDisconnected = false;
+  }
+
+  log(...args) {
+    if (this.debug) {
+      console.log("[LocalMeet]", ...args);
+    }
+  }
+
+  async apiPost(endpoint, payload) {
+    const cleanEndpoint = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+    const url = `${this.serverUrl}${cleanEndpoint}`;
+
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+
+    const rawText = await res.text();
+    let data = null;
+    if (rawText) {
+      try {
+        data = JSON.parse(rawText);
+      } catch {
+        data = null;
+      }
+    }
+
+    if (!res.ok) {
+      throw new Error(
+        data?.detail || `Error en servidor (${res.status}): ${rawText.slice(0, 120)}`
+      );
+    }
+    return data;
+  }
+
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set());
+    }
+    this.listeners.get(event).add(callback);
+    return this;
+  }
+
+  off(event, callback) {
+    const set = this.listeners.get(event);
+    if (set) {
+      set.delete(callback);
+    }
+    return this;
+  }
+
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const cb of set) {
+      try {
+        cb(...args);
+      } catch (err) {
+        if (this.debug) console.error(`[LocalMeet] Error en listener de '${event}':`, err);
+      }
+    }
+  }
+
+  getHostPeerId() {
+    const cleanHash = this.roomHash.replace(/[^a-z0-9]/g, "");
+    return `lm-host-${cleanHash}`;
+  }
+
+  getMyPeerId() {
+    if (this.isHost) {
+      return this.getHostPeerId();
+    }
+    const cleanId = this.localParticipant.identity.replace(/[^a-z0-9]/g, "");
+    return `lm-${cleanId}`;
+  }
+
+  async connect() {
+    const myPeerId = this.getMyPeerId();
+    this.localParticipant.peerId = myPeerId;
+
+    if (typeof window !== "undefined" && typeof window.Peer === "function") {
+      await this.initPeerWithRetry(myPeerId, 3).catch(() => {});
+    }
+
+    this.startWorkerSyncLoop();
+
+    if (this.isHost) {
+      if (this.cfCallsReady) {
+        await this.initCloudflareCallsSession().catch(() => {
+          this.cfCallsReady = false;
+        });
+      }
+      await this.flushWorkerSync();
+    } else {
+      await this.connectGuestToHost();
+    }
+    return this;
+  }
+
+  initPeerWithRetry(peerId, attemptsLeft) {
+    return new Promise((resolve) => {
+      let currentTryId = peerId;
+      const peer = new window.Peer(currentTryId, {
+        debug: 0,
+        pingInterval: 5000,
+        config: {
+          iceServers: this.iceServers,
+        },
+      });
+
+      let settled = false;
+      const finish = () => {
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      };
+
+      const openTimeout = setTimeout(finish, 4500);
+
+      peer.on("open", (id) => {
+        clearTimeout(openTimeout);
+        this.peer = peer;
+        this.localParticipant.peerId = id || currentTryId;
+        this.bindPeerEvents(peer);
+        finish();
+      });
+
+      peer.on("error", (err) => {
+        if (!this.peer) {
+          clearTimeout(openTimeout);
+          try {
+            peer.destroy();
+          } catch {}
+          if (err?.type === "unavailable-id" && attemptsLeft > 1) {
+            const nextId =
+              attemptsLeft === 2 && this.isHost
+                ? `${peerId}-${Math.random().toString(36).slice(2, 6)}`
+                : peerId;
+            setTimeout(() => {
+              this.initPeerWithRetry(nextId, attemptsLeft - 1).then(finish);
+            }, 600);
+            return;
+          }
+          finish();
+        }
+      });
+    });
+  }
+
+  bindPeerEvents(peer) {
+    peer.on("connection", (conn) => {
+      this.handleIncomingDataConnection(conn);
+    });
+
+    peer.on("call", (call) => {
+      this.handleIncomingMediaCall(call);
+    });
+
+    peer.on("disconnected", () => {
+      if (!this.isDisconnected && !peer.destroyed) {
+        try {
+          peer.reconnect();
+        } catch {}
+      }
+    });
+
+    if (this.peerKeepAliveTimer) clearInterval(this.peerKeepAliveTimer);
+    this.peerKeepAliveTimer = setInterval(() => {
+      if (this.isDisconnected) return;
+      if (this.peer && this.peer.disconnected && !this.peer.destroyed) {
+        try {
+          this.peer.reconnect();
+        } catch {}
+      }
+      if (!this.isHost && (!this.hostConn || !this.hostConn.open) && this.peer?.open) {
+        this.tryOpenPeerDataChannelToHost();
+      }
+    }, 5000);
+  }
+
+  enqueueHttpSignal(targetId, packet) {
+    const msgId =
+      packet?._msgId || `m_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    const enriched = { ...packet, _msgId: msgId, _sentAt: packet?._sentAt || Date.now() };
+    this.processedSignalIds.add(msgId);
+    this.outgoingHttpSignals.push({
+      id: msgId,
+      targetId: targetId || "all",
+      packet: enriched,
+    });
+    this.flushWorkerSync();
+    return enriched;
+  }
+
+  startWorkerSyncLoop() {
+    if (this.syncTimer) clearInterval(this.syncTimer);
+    this.syncTimer = setInterval(() => {
+      if (!this.isDisconnected) {
+        this.flushWorkerSync();
+      }
+    }, 1300);
+  }
+
+  async flushWorkerSync() {
+    if (this.isDisconnected || this.syncInFlight) return;
+    this.syncInFlight = true;
+
+    const batch = [];
+    let batchBytes = 0;
+    while (this.outgoingHttpSignals.length > 0 && batch.length < 12) {
+      const next = this.outgoingHttpSignals[0];
+      const size = JSON.stringify(next).length;
+      if (batch.length > 0 && batchBytes + size > 48000) break;
+      batch.push(this.outgoingHttpSignals.shift());
+      batchBytes += size;
+    }
+
+    try {
+      const res = await this.apiPost("/api/room-sync", {
+        room_hash: this.roomHash,
+        identity: this.localParticipant.identity,
+        peer_id: this.localParticipant.peerId || "",
+        is_host: this.isHost,
+        joined_at: this.joinedAt,
+        outgoing: batch,
+      });
+
+      if (res?.host_peer_id && res.host_peer_id !== this.knownHostPeerId) {
+        this.knownHostPeerId = res.host_peer_id;
+        if (!this.isHost && (!this.hostConn || !this.hostConn.open)) {
+          this.tryOpenPeerDataChannelToHost();
+        }
+      }
+
+      if (Array.isArray(res?.messages)) {
+        for (const item of res.messages) {
+          if (!item?.id || this.processedSignalIds.has(item.id)) continue;
+          this.processedSignalIds.add(item.id);
+          const pkt = item.packet;
+          if (!pkt || typeof pkt !== "object") continue;
+
+          if (this.isHost) {
+            this.handleSignalingMessageAtHost(null, {
+              ...pkt,
+              senderId: pkt.senderId || item.senderId,
+            });
+          } else {
+            await this.handleSignalingMessageFromHost(pkt);
+          }
+        }
+      }
+    } catch {
+      if (batch.length > 0) {
+        this.outgoingHttpSignals.unshift(...batch);
+      }
+    } finally {
+      this.syncInFlight = false;
+      if (this.outgoingHttpSignals.length > 0 && !this.isDisconnected) {
+        setTimeout(() => this.flushWorkerSync(), 120);
+      }
+    }
+  }
+
+  tryOpenPeerDataChannelToHost() {
+    if (this.isDisconnected || this.isHost || !this.peer?.open) return;
+    const targetPeerId = this.knownHostPeerId || this.getHostPeerId();
+    if (!targetPeerId) return;
+
+    try {
+      const conn = this.peer.connect(targetPeerId, {
+        reliable: true,
+        serialization: "json",
+      });
+      if (!conn) return;
+
+      conn.on("open", () => {
+        this.hostConn = conn;
+        const helloPkt = {
+          type: "hello_guest",
+          identity: this.localParticipant.identity,
+          name: this.localParticipant.name,
+          peerId: this.localParticipant.peerId,
+        };
+        conn.send(helloPkt);
+      });
+
+      conn.on("data", (msg) => {
+        if (msg?._msgId) {
+          if (this.processedSignalIds.has(msg._msgId)) return;
+          this.processedSignalIds.add(msg._msgId);
+        }
+        this.handleSignalingMessageFromHost(msg);
+      });
+
+      conn.on("close", () => {
+        if (this.hostConn === conn) {
+          this.hostConn = null;
+        }
+      });
+    } catch {}
+  }
+
+  async connectGuestToHost() {
+    const helloPkt = {
+      type: "hello_guest",
+      identity: this.localParticipant.identity,
+      name: this.localParticipant.name,
+      peerId: this.localParticipant.peerId,
+    };
+
+    this.enqueueHttpSignal("host", helloPkt);
+    await this.flushWorkerSync();
+
+    this.tryOpenPeerDataChannelToHost();
+
+    const helloInterval = setInterval(() => {
+      if (this.isDisconnected || this.localParticipant.permissions?.canSubscribe) {
+        clearInterval(helloInterval);
+        return;
+      }
+      this.enqueueHttpSignal("host", {
+        ...helloPkt,
+        peerId: this.localParticipant.peerId,
+      });
+      if (this.hostConn?.open) {
+        try {
+          this.hostConn.send({
+            ...helloPkt,
+            peerId: this.localParticipant.peerId,
+          });
+        } catch {}
+      }
+    }, 3200);
+  }
+
+  handleIncomingDataConnection(conn) {
+    conn.on("data", (msg) => {
+      if (!msg || typeof msg !== "object") return;
+      if (msg._msgId) {
+        if (this.processedSignalIds.has(msg._msgId)) return;
+        this.processedSignalIds.add(msg._msgId);
+      }
+
+      if (this.isHost) {
+        this.handleSignalingMessageAtHost(conn, msg);
+      } else {
+        this.handleSignalingMessageFromHost(msg);
+      }
+    });
+
+    conn.on("close", () => {
+      if (this.isHost && conn._guestIdentity) {
+        this.guestConns.delete(conn._guestIdentity);
+      }
+    });
+  }
+
+  handleSignalingMessageAtHost(conn, msg) {
+    if (msg.type === "hello_guest") {
+      const guestId = msg.identity;
+      if (!guestId) return;
+      if (conn) {
+        conn._guestIdentity = guestId;
+        this.guestConns.set(guestId, conn);
+      }
+
+      const existing = this.remoteParticipants.get(guestId);
+      if (existing) {
+        if (msg.peerId) existing.peerId = msg.peerId;
+        if (msg.name) existing.name = msg.name;
+        if (existing.permissions?.canSubscribe) {
+          const roster = this.buildApprovedRosterList();
+          const approvePkt = this.enqueueHttpSignal(guestId, {
+            type: "decision",
+            action: "approve",
+            roomTitle: this.roomTitle,
+            roster,
+          });
+          if (conn?.open) conn.send(approvePkt);
+        }
+        return;
+      }
+
+      const guestParticipant = new HybridParticipant({
+        identity: guestId,
+        name: msg.name || "Invitado",
+        metadata: JSON.stringify({ role: "guest", status: "waiting" }),
+        permissions: {
+          canPublish: false,
+          canSubscribe: false,
+          canPublishData: false,
+        },
+        isLocal: false,
+        room: this,
+      });
+      guestParticipant.peerId = msg.peerId || "";
+
+      this.remoteParticipants.set(guestId, guestParticipant);
+      this.emit(RoomEvents.ParticipantConnected, guestParticipant);
+      return;
+    }
+
+    const senderId = conn?._guestIdentity || msg.identity || msg.senderId;
+    const senderP = this.remoteParticipants.get(senderId);
+    if (!senderP) return;
+
+    if (msg.type === "media_state") {
+      this.applyRemoteMediaState(senderP, msg);
+      this.broadcastRoster();
+      return;
+    }
+
+    if (msg.type === "rtc_signal") {
+      const targetId = msg.targetId;
+      if (!targetId || targetId === this.localParticipant.identity) {
+        this.handleRtcSignal(senderId, senderP.name || msg.senderName, msg);
+      } else {
+        const targetConn = this.guestConns.get(targetId);
+        const targetP = this.remoteParticipants.get(targetId);
+        const forwarded = {
+          ...msg,
+          senderId,
+          senderName: senderP.name || msg.senderName,
+        };
+        this.enqueueHttpSignal(targetId, forwarded);
+        if (targetConn?.open && targetP?.permissions?.canSubscribe) {
+          targetConn.send(forwarded);
+        }
+      }
+      return;
+    }
+
+    if (msg.type === "app_data") {
+      this.deliverAppData(msg.senderId, msg.senderName, msg);
+      this.enqueueHttpSignal("all", msg);
+      for (const [id, gConn] of this.guestConns.entries()) {
+        if (id !== senderId && gConn.open) {
+          const gp = this.remoteParticipants.get(id);
+          if (gp?.permissions?.canSubscribe) {
+            gConn.send(msg);
+          }
+        }
+      }
+    }
+  }
+
+  async handleSignalingMessageFromHost(msg) {
+    if (!msg || typeof msg !== "object") return;
+
+    if (msg.type === "decision") {
+      if (msg.action === "reject") {
+        this.disconnect();
+        this.emit(RoomEvents.Disconnected);
+        return;
+      }
+
+      if (msg.action === "approve") {
+        if (msg.roomTitle) {
+          this.roomTitle = msg.roomTitle;
+        }
+        this.localParticipant.metadata = JSON.stringify({
+          role: "guest",
+          status: "approved",
+          room_title: this.roomTitle,
+        });
+        this.localParticipant.permissions = {
+          canPublish: true,
+          canSubscribe: true,
+          canPublishData: true,
+        };
+
+        if (this.cfCallsReady) {
+          await this.initCloudflareCallsSession().catch(() => {
+            this.cfCallsReady = false;
+          });
+        }
+
+        if (Array.isArray(msg.roster)) {
+          await this.syncRosterFromHost(msg.roster);
+        }
+
+        this.emit(RoomEvents.ParticipantMetadataChanged, this.localParticipant);
+        this.emit(RoomEvents.ParticipantPermissionsChanged, this.localParticipant);
+      }
+      return;
+    }
+
+    if (msg.type === "roster") {
+      if (Array.isArray(msg.roster)) {
+        await this.syncRosterFromHost(msg.roster);
+      }
+      return;
+    }
+
+    if (msg.type === "rtc_signal") {
+      this.handleRtcSignal(msg.senderId, msg.senderName, msg);
+      return;
+    }
+
+    if (msg.type === "app_data") {
+      this.deliverAppData(msg.senderId, msg.senderName, msg);
+      return;
+    }
+
+    if (msg.type === "kicked" || msg.type === "room_ended") {
+      if (msg._sentAt && msg._sentAt < this.joinedAt - 3000) return;
+      this.disconnect();
+      this.emit(RoomEvents.Disconnected);
+    }
+  }
+
+  async deliverAppData(senderId, senderName, msgPacket) {
+    if (!msgPacket || senderId === this.localParticipant.identity) return;
+    let plaintext = "";
+    if (msgPacket.cipher) {
+      try {
+        plaintext = await decryptDataPacket(this.roomHash, msgPacket.cipher);
+      } catch {
+        return;
+      }
+    } else if (typeof msgPacket.text === "string") {
+      plaintext = msgPacket.text;
+    }
+    if (!plaintext) return;
+
+    const participant = this.remoteParticipants.get(senderId) || {
+      identity: senderId,
+      name: senderName || "Participante",
+    };
+    const payload = new TextEncoder().encode(plaintext);
+    this.emit(RoomEvents.DataReceived, payload, plaintext, participant);
+  }
+
+  async admitGuest(identity) {
+    if (!this.isHost) return;
+    try {
+      await this.apiPost("/api/decide", {
+        room_hash: this.roomHash,
+        host_secret: this.hostSecret,
+        identity,
+        action: "approve",
+      });
+    } catch {}
+
+    const conn = this.guestConns.get(identity);
+    const guestP = this.remoteParticipants.get(identity);
+    if (!guestP) return;
+
+    guestP.metadata = JSON.stringify({
+      role: "guest",
+      status: "approved",
+      room_title: this.roomTitle,
+    });
+    guestP.permissions = {
+      canPublish: true,
+      canSubscribe: true,
+      canPublishData: true,
+    };
+
+    const roster = this.buildApprovedRosterList();
+    const approvePkt = this.enqueueHttpSignal(identity, {
+      type: "decision",
+      action: "approve",
+      roomTitle: this.roomTitle,
+      roster,
+    });
+    if (conn?.open) {
+      conn.send(approvePkt);
+    }
+
+    this.emit(RoomEvents.ParticipantMetadataChanged, guestP);
+    this.broadcastRoster();
+
+    if (!this.cfCallsReady) {
+      this.startDirectUserMediaToPeer(guestP.identity);
+      if (guestP.peerId) {
+        this.callPeerWithLocalTracks(guestP.peerId, guestP.identity);
+      }
+    } else if (this.getLocalScreenMediaStream()) {
+      this.startDirectScreenShareToPeer(guestP.identity);
+      if (guestP.peerId) {
+        this.callPeerScreenShare(guestP.peerId, guestP.identity);
+      }
+    }
+  }
+
+  async rejectGuest(identity) {
+    if (!this.isHost) return;
+    try {
+      await this.apiPost("/api/decide", {
+        room_hash: this.roomHash,
+        host_secret: this.hostSecret,
+        identity,
+        action: "reject",
+      });
+    } catch {}
+
+    const conn = this.guestConns.get(identity);
+    const guestP = this.remoteParticipants.get(identity);
+    if (!guestP) return;
+
+    const rejectPkt = this.enqueueHttpSignal(identity, {
+      type: "decision",
+      action: "reject",
+    });
+    if (conn?.open) {
+      conn.send(rejectPkt);
+      setTimeout(() => conn.close(), 200);
+    }
+    this.guestConns.delete(identity);
+    this.remoteParticipants.delete(identity);
+    this.emit(RoomEvents.ParticipantDisconnected, guestP);
+  }
+
+  buildParticipantSummary(p) {
+    const micPub = p.getTrackPublication(TrackSources.Microphone);
+    const camPub = p.getTrackPublication(TrackSources.Camera);
+    const scrPub = p.getTrackPublication(TrackSources.ScreenShare);
+    return {
+      identity: p.identity,
+      name: p.name,
+      peerId: p.peerId,
+      metadata: p.metadata,
+      micMuted: !micPub || micPub.isMuted,
+      camMuted: !camPub || camPub.isMuted,
+      hasScreen: Boolean(scrPub && !scrPub.isMuted),
+      cfSessionId: p.cfSessionId || "",
+      cfPublishedTracks: p.cfPublishedTracks || [],
+    };
+  }
+
+  buildApprovedRosterList() {
+    const list = [this.buildParticipantSummary(this.localParticipant)];
+    for (const p of this.remoteParticipants.values()) {
+      if (p.permissions?.canSubscribe) {
+        list.push(this.buildParticipantSummary(p));
+      }
+    }
+    return list;
+  }
+
+  broadcastRoster() {
+    if (!this.isHost) return;
+    const roster = this.buildApprovedRosterList();
+    const rosterPkt = this.enqueueHttpSignal("all", { type: "roster", roster });
+    for (const [id, conn] of this.guestConns.entries()) {
+      const gp = this.remoteParticipants.get(id);
+      if (conn.open && gp?.permissions?.canSubscribe) {
+        conn.send(rosterPkt);
+      }
+    }
+    if (this.cfCallsReady) {
+      for (const p of this.remoteParticipants.values()) {
+        if (p.permissions?.canSubscribe && p.cfSessionId) {
+          this.pullRemoteTracksFromCloudflare(p);
+        }
+      }
+    }
+  }
+
+  async syncRosterFromHost(roster) {
+    const incomingIds = new Set();
+    let changed = false;
+
+    for (const item of roster) {
+      if (item.identity === this.localParticipant.identity) continue;
+      incomingIds.add(item.identity);
+
+      let p = this.remoteParticipants.get(item.identity);
+      const isNew = !p;
+      if (!p) {
+        p = new HybridParticipant({
+          identity: item.identity,
+          name: item.name,
+          metadata: item.metadata || JSON.stringify({ role: "guest", status: "approved" }),
+          permissions: {
+            canPublish: true,
+            canSubscribe: true,
+            canPublishData: true,
+          },
+          isLocal: false,
+          room: this,
+        });
+        this.remoteParticipants.set(item.identity, p);
+        changed = true;
+      }
+
+      if (item.name && p.name !== item.name) {
+        p.name = item.name;
+        changed = true;
+      }
+      if (item.peerId && p.peerId !== item.peerId) {
+        p.peerId = item.peerId;
+      }
+      if (item.metadata && p.metadata !== item.metadata) {
+        p.metadata = item.metadata;
+        changed = true;
+      }
+      const mediaChanged = this.applyRemoteMediaState(p, item, false);
+      if (mediaChanged) changed = true;
+
+      if (isNew && !this.cfCallsReady) {
+        this.startDirectUserMediaToPeer(p.identity);
+        if (p.peerId) {
+          this.callPeerWithLocalTracks(p.peerId, p.identity);
+        }
+      }
+
+      if (isNew && this.getLocalScreenMediaStream()) {
+        this.startDirectScreenShareToPeer(p.identity);
+      }
+
+      if (this.cfCallsReady && p.cfSessionId) {
+        await this.pullRemoteTracksFromCloudflare(p);
+      }
+    }
+
+    for (const [id, p] of this.remoteParticipants.entries()) {
+      if (!incomingIds.has(id)) {
+        this.cleanupRemoteParticipantTracks(p);
+        this.remoteParticipants.delete(id);
+        changed = true;
+      }
+    }
+
+    if (changed) {
+      this.emit(RoomEvents.ParticipantConnected);
+    }
+  }
+
+  applyRemoteMediaState(participant, state, shouldEmit = true) {
+    let changed = false;
+    if (typeof state.cfSessionId === "string" && participant.cfSessionId !== state.cfSessionId) {
+      participant.cfSessionId = state.cfSessionId;
+      changed = true;
+    }
+    if (Array.isArray(state.cfPublishedTracks)) {
+      participant.cfPublishedTracks = state.cfPublishedTracks;
+    }
+
+    const micPub = participant.getTrackPublication(TrackSources.Microphone);
+    if (micPub && typeof state.micMuted === "boolean" && micPub.isMuted !== state.micMuted) {
+      micPub.isMuted = state.micMuted;
+      changed = true;
+    }
+
+    const camPub = participant.getTrackPublication(TrackSources.Camera);
+    if (camPub && typeof state.camMuted === "boolean" && camPub.isMuted !== state.camMuted) {
+      camPub.isMuted = state.camMuted;
+      changed = true;
+    }
+
+    if (state.hasScreen === false) {
+      const scrPub = participant.getTrackPublication(TrackSources.ScreenShare);
+      if (scrPub) {
+        participant.setPublication(TrackSources.ScreenShare, null);
+        this.emit(RoomEvents.TrackUnpublished, scrPub, participant);
+        if (scrPub.track) {
+          this.emit(RoomEvents.TrackUnsubscribed, scrPub.track, scrPub, participant);
+        }
+        changed = true;
+      }
+    }
+
+    if (this.isHost && this.cfCallsReady && participant.cfSessionId) {
+      this.pullRemoteTracksFromCloudflare(participant);
+    }
+    if (shouldEmit && changed) {
+      this.emit(RoomEvents.TrackMuted);
+    }
+    return changed;
+  }
+
+  sendLocalMediaState() {
+    const summary = this.buildParticipantSummary(this.localParticipant);
+    if (this.isHost) {
+      this.broadcastRoster();
+    } else {
+      const pkt = this.enqueueHttpSignal("host", {
+        type: "media_state",
+        ...summary,
+      });
+      if (this.hostConn?.open) {
+        this.hostConn.send(pkt);
+      }
+    }
+  }
+
+  async enableCameraAndMicrophone() {
+    const stream = await navigator.mediaDevices.getUserMedia({
+      video: { width: { ideal: 1280 }, height: { ideal: 720 } },
+      audio: {
+        echoCancellation: true,
+        noiseSuppression: true,
+        autoGainControl: true,
+      },
+    });
+
+    const audioTrack = stream.getAudioTracks()[0];
+    const videoTrack = stream.getVideoTracks()[0];
+
+    if (audioTrack) {
+      this.setLocalPublicationTrack(TrackSources.Microphone, audioTrack, TrackKinds.Audio);
+    }
+    if (videoTrack) {
+      this.setLocalPublicationTrack(TrackSources.Camera, videoTrack, TrackKinds.Video);
+    }
+
+    await this.syncOutgoingMedia();
+  }
+
+  async setMicrophoneEnabled(enabled) {
+    let micPub = this.localParticipant.getTrackPublication(TrackSources.Microphone);
+    if (enabled) {
+      if (!micPub?.track?.mediaStreamTrack || micPub.track.mediaStreamTrack.readyState === "ended") {
+        const stream = await navigator.mediaDevices.getUserMedia({
+          audio: {
+            echoCancellation: true,
+            noiseSuppression: true,
+            autoGainControl: true,
+          },
+        });
+        const audioTrack = stream.getAudioTracks()[0];
+        this.setLocalPublicationTrack(TrackSources.Microphone, audioTrack, TrackKinds.Audio);
+      } else {
+        micPub.track.mediaStreamTrack.enabled = true;
+        micPub.isMuted = false;
+      }
+    } else if (micPub) {
+      if (micPub.track?.mediaStreamTrack) {
+        micPub.track.mediaStreamTrack.enabled = false;
+      }
+      micPub.isMuted = true;
+    }
+
+    await this.syncOutgoingMedia();
+    this.emit(enabled ? RoomEvents.TrackUnmuted : RoomEvents.TrackMuted, micPub);
+  }
+
+  async setCameraEnabled(enabled) {
+    let camPub = this.localParticipant.getTrackPublication(TrackSources.Camera);
+    if (enabled) {
+      if (!camPub?.track?.mediaStreamTrack || camPub.track.mediaStreamTrack.readyState === "ended") {
+        const stream = await navigator.mediaDevices.getUserMedia({
+          video: { width: { ideal: 1280 }, height: { ideal: 720 } },
+        });
+        const videoTrack = stream.getVideoTracks()[0];
+        this.setLocalPublicationTrack(TrackSources.Camera, videoTrack, TrackKinds.Video);
+      } else {
+        camPub.track.mediaStreamTrack.enabled = true;
+        camPub.isMuted = false;
+      }
+    } else if (camPub) {
+      if (camPub.track?.mediaStreamTrack) {
+        camPub.track.mediaStreamTrack.stop();
+      }
+      camPub.isMuted = true;
+    }
+
+    await this.syncOutgoingMedia();
+    this.emit(enabled ? RoomEvents.TrackUnmuted : RoomEvents.TrackMuted, camPub);
+  }
+
+  async setScreenShareEnabled(enabled, stopTracks = true) {
+    const existingPub = this.localParticipant.getTrackPublication(TrackSources.ScreenShare);
+    if (!enabled) {
+      if (existingPub) {
+        if (stopTracks && existingPub.track) {
+          existingPub.track.stop();
+        }
+        this.localParticipant.setPublication(TrackSources.ScreenShare, null);
+        this.closeOutgoingScreenCalls();
+        if (this.cfCallsReady) {
+          const prevTr = this.cfTransceivers.get(this.currentScreenTrackName);
+          if (prevTr?.sender) {
+            prevTr.sender.replaceTrack(null).catch(() => {});
+          }
+          this.localParticipant.cfPublishedTracks = (
+            this.localParticipant.cfPublishedTracks || []
+          ).filter((t) => t !== "screen" && !t.startsWith("screen_"));
+        }
+        this.sendLocalMediaState();
+        this.emit(RoomEvents.LocalTrackUnpublished, existingPub);
+      }
+      return null;
+    }
+
+    const stream = await navigator.mediaDevices.getDisplayMedia({
+      video: { frameRate: { ideal: 30, max: 30 } },
+      audio: false,
+    });
+    const screenVideoTrack = stream.getVideoTracks()[0];
+    if (!screenVideoTrack) return null;
+
+    this.currentScreenTrackName = `screen_${Date.now().toString(36).slice(-4)}`;
+
+    const pub = this.setLocalPublicationTrack(
+      TrackSources.ScreenShare,
+      screenVideoTrack,
+      TrackKinds.Video
+    );
+
+    await this.syncOutgoingMedia(true);
+    this.emit(RoomEvents.LocalTrackPublished, pub);
+    return pub;
+  }
+
+  async startScreenShare() {
+    return this.setScreenShareEnabled(true);
+  }
+
+  async stopScreenShare() {
+    return this.setScreenShareEnabled(false);
+  }
+
+  setLocalPublicationTrack(source, mediaStreamTrack, kind) {
+    const hTrack = new HybridTrack(mediaStreamTrack, kind, source);
+    const pub = new HybridPublication({
+      trackSid: `${source}_${this.localParticipant.identity}`,
+      source,
+      track: hTrack,
+      isMuted: false,
+    });
+    this.localParticipant.setPublication(source, pub);
+    return pub;
+  }
+
+  async syncOutgoingMedia(includeScreen = false) {
+    if (includeScreen) {
+      this.callAllPeersScreenShare();
+    }
+
+    if (this.cfCallsReady) {
+      try {
+        await this.pushLocalTracksToCloudflare();
+        this.sendLocalMediaState();
+        if (includeScreen) {
+          setTimeout(() => {
+            if (!this.isDisconnected) this.sendLocalMediaState();
+          }, 650);
+        }
+        return;
+      } catch {
+        this.cfCallsReady = false;
+      }
+    }
+
+    if (!includeScreen) {
+      for (const p of this.remoteParticipants.values()) {
+        if (p.permissions?.canSubscribe) {
+          this.startDirectUserMediaToPeer(p.identity);
+          if (p.peerId) {
+            this.callPeerWithLocalTracks(p.peerId, p.identity, false);
+          }
+        }
+      }
+    }
+    this.sendLocalMediaState();
+  }
+
+  sendSignalingToParticipant(targetIdentity, packet) {
+    const payload = {
+      ...packet,
+      targetId: targetIdentity,
+      senderId: this.localParticipant.identity,
+      senderName: this.localParticipant.name,
+    };
+
+    const enriched = this.enqueueHttpSignal(targetIdentity, payload);
+    if (this.isHost) {
+      const conn = this.guestConns.get(targetIdentity);
+      if (conn?.open) {
+        conn.send(enriched);
+      }
+    } else if (this.hostConn?.open) {
+      this.hostConn.send(enriched);
+    }
+  }
+
+  async startDirectUserMediaToPeer(remoteIdentity) {
+    if (!remoteIdentity || this.cfCallsReady) return;
+    const userStream = this.getLocalUserMediaStream();
+    if (!userStream) return;
+
+    const pcKey = `${remoteIdentity}:user`;
+    const existingPc = this.directScreenPcs.get(pcKey);
+    const isAlive = Boolean(
+      existingPc &&
+        existingPc.connectionState !== "closed" &&
+        existingPc.connectionState !== "failed" &&
+        existingPc.iceConnectionState !== "closed" &&
+        existingPc.iceConnectionState !== "failed"
+    );
+
+    if (isAlive && typeof existingPc.getSenders === "function") {
+      const senders = existingPc.getSenders();
+      const newAudio = userStream.getAudioTracks()[0] || null;
+      const newVideo = userStream.getVideoTracks()[0] || null;
+      const audioSender = senders.find((s) => s.track?.kind === "audio");
+      const videoSender = senders.find((s) => s.track?.kind === "video");
+      const canReplaceAudio = !newAudio || Boolean(audioSender);
+      const canReplaceVideo = !newVideo || Boolean(videoSender);
+      if (canReplaceAudio && canReplaceVideo) {
+        if (audioSender && newAudio) audioSender.replaceTrack(newAudio).catch(() => {});
+        if (videoSender) videoSender.replaceTrack(newVideo).catch(() => {});
+        return;
+      }
+    }
+
+    if (existingPc) {
+      try {
+        existingPc.close();
+      } catch {}
+      this.directScreenPcs.delete(pcKey);
+    }
+    this.pendingScreenIce.delete(`${pcKey}:caller`);
+
+    const pc = new RTCPeerConnection({
+      iceServers: this.iceServers,
+    });
+    this.directScreenPcs.set(pcKey, pc);
+
+    pc.onicecandidate = (ev) => {
+      if (ev.candidate && this.directScreenPcs.get(pcKey) === pc) {
+        this.sendSignalingToParticipant(remoteIdentity, {
+          type: "rtc_signal",
+          streamKind: "user",
+          signalType: "candidate",
+          role: "caller",
+          candidate: ev.candidate.toJSON ? ev.candidate.toJSON() : ev.candidate,
+        });
+      }
+    };
+
+    for (const track of userStream.getTracks()) {
+      track.enabled = true;
+      pc.addTrack(track, userStream);
+    }
+
+    try {
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      this.sendSignalingToParticipant(remoteIdentity, {
+        type: "rtc_signal",
+        streamKind: "user",
+        signalType: "offer",
+        sdp: {
+          type: offer.type,
+          sdp: offer.sdp,
+        },
+      });
+    } catch {}
+  }
+
+  async startDirectScreenShareToPeer(remoteIdentity) {
+    if (!remoteIdentity) return;
+    const screenStream = this.getLocalScreenMediaStream();
+    const screenTrack = screenStream?.getVideoTracks()?.[0];
+    if (!screenStream || !screenTrack) return;
+
+    screenTrack.enabled = true;
+    const pcKey = `${remoteIdentity}:screen`;
+    const prevPc = this.directScreenPcs.get(pcKey);
+    if (prevPc) {
+      try {
+        prevPc.close();
+      } catch {}
+      this.directScreenPcs.delete(pcKey);
+    }
+    this.pendingScreenIce.delete(`${pcKey}:caller`);
+
+    const pc = new RTCPeerConnection({
+      iceServers: this.iceServers,
+    });
+    this.directScreenPcs.set(pcKey, pc);
+
+    pc.onicecandidate = (ev) => {
+      if (ev.candidate && this.directScreenPcs.get(pcKey) === pc) {
+        this.sendSignalingToParticipant(remoteIdentity, {
+          type: "rtc_signal",
+          streamKind: "screen",
+          signalType: "candidate",
+          role: "caller",
+          candidate: ev.candidate.toJSON ? ev.candidate.toJSON() : ev.candidate,
+        });
+      }
+    };
+
+    pc.addTrack(screenTrack, screenStream);
+
+    try {
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      this.sendSignalingToParticipant(remoteIdentity, {
+        type: "rtc_signal",
+        streamKind: "screen",
+        signalType: "offer",
+        sdp: {
+          type: offer.type,
+          sdp: offer.sdp,
+        },
+      });
+    } catch {}
+  }
+
+  handleRtcSignal(senderId, senderName, msg) {
+    if (!senderId || !msg) return Promise.resolve();
+    const streamKind = msg.streamKind === "user" ? "user" : "screen";
+    const pcKey = `${senderId}:${streamKind}`;
+    const prevChain = this.rtcSignalQueues.get(pcKey) || Promise.resolve();
+    const nextChain = prevChain
+      .then(() => this._processRtcSignalSequential(senderId, senderName, msg, streamKind, pcKey))
+      .catch(() => {});
+    this.rtcSignalQueues.set(pcKey, nextChain);
+    return nextChain;
+  }
+
+  async _processRtcSignalSequential(senderId, senderName, msg, streamKind, pcKey) {
+    let participant = this.remoteParticipants.get(senderId);
+    if (!participant) {
+      participant = new HybridParticipant({
+        identity: senderId,
+        name: senderName || "Participante",
+        metadata: JSON.stringify({ role: "guest", status: "approved" }),
+        permissions: { canPublish: true, canSubscribe: true, canPublishData: true },
+        isLocal: false,
+        room: this,
+      });
+      this.remoteParticipants.set(senderId, participant);
+    }
+
+    const attachIncomingTrack = (track) => {
+      if (!track) return;
+      if (streamKind === "screen") {
+        if (track.kind === "video") {
+          this.attachRemoteTrackToParticipant(
+            participant,
+            track,
+            TrackKinds.Video,
+            TrackSources.ScreenShare
+          );
+        }
+      } else if (track.kind === "audio") {
+        this.attachRemoteTrackToParticipant(
+          participant,
+          track,
+          TrackKinds.Audio,
+          TrackSources.Microphone
+        );
+      } else if (track.kind === "video") {
+        this.attachRemoteTrackToParticipant(
+          participant,
+          track,
+          TrackKinds.Video,
+          TrackSources.Camera
+        );
+      }
+    };
+
+    if (msg.signalType === "offer" && msg.sdp) {
+      const prevPc = this.incomingScreenPcs.get(pcKey);
+      if (prevPc) {
+        const prevRemoteSdp =
+          prevPc.currentRemoteDescription?.sdp || prevPc.remoteDescription?.sdp || "";
+        if (
+          prevRemoteSdp &&
+          prevRemoteSdp === msg.sdp.sdp &&
+          prevPc.connectionState !== "closed" &&
+          prevPc.connectionState !== "failed"
+        ) {
+          return;
+        }
+        try {
+          prevPc.close();
+        } catch {}
+      }
+
+      const pc = new RTCPeerConnection({
+        iceServers: this.iceServers,
+      });
+      this.incomingScreenPcs.set(pcKey, pc);
+
+      pc.ontrack = (ev) => {
+        if (ev.track) {
+          attachIncomingTrack(ev.track);
+        } else if (ev.streams?.[0]) {
+          for (const t of ev.streams[0].getTracks()) {
+            attachIncomingTrack(t);
+          }
+        }
+      };
+
+      pc.onicecandidate = (ev) => {
+        if (ev.candidate && this.incomingScreenPcs.get(pcKey) === pc) {
+          this.sendSignalingToParticipant(senderId, {
+            type: "rtc_signal",
+            streamKind,
+            signalType: "candidate",
+            role: "callee",
+            candidate: ev.candidate.toJSON ? ev.candidate.toJSON() : ev.candidate,
+          });
+        }
+      };
+
+      try {
+        await pc.setRemoteDescription(new RTCSessionDescription(msg.sdp));
+
+        for (const tr of pc.getTransceivers()) {
+          if (tr.direction === "inactive" || tr.direction === "sendonly") {
+            try {
+              tr.direction = "recvonly";
+            } catch {}
+          }
+          if (tr.receiver?.track) {
+            attachIncomingTrack(tr.receiver.track);
+          }
+        }
+
+        const queuedKey = `${pcKey}:callee`;
+        const queued = this.pendingScreenIce.get(queuedKey) || [];
+        this.pendingScreenIce.delete(queuedKey);
+        for (const cand of queued) {
+          await pc.addIceCandidate(new RTCIceCandidate(cand)).catch(() => {});
+        }
+
+        const answer = await pc.createAnswer();
+        await pc.setLocalDescription(answer);
+        this.sendSignalingToParticipant(senderId, {
+          type: "rtc_signal",
+          streamKind,
+          signalType: "answer",
+          sdp: {
+            type: answer.type,
+            sdp: answer.sdp,
+          },
+        });
+      } catch {}
+      return;
+    }
+
+    if (msg.signalType === "answer" && msg.sdp) {
+      const pc = this.directScreenPcs.get(pcKey);
+      if (!pc || pc.signalingState === "stable") return;
+      try {
+        await pc.setRemoteDescription(new RTCSessionDescription(msg.sdp));
+        const queuedKey = `${pcKey}:caller`;
+        const queued = this.pendingScreenIce.get(queuedKey) || [];
+        this.pendingScreenIce.delete(queuedKey);
+        for (const cand of queued) {
+          await pc.addIceCandidate(new RTCIceCandidate(cand)).catch(() => {});
+        }
+      } catch {}
+      return;
+    }
+
+    if (msg.signalType === "candidate" && msg.candidate) {
+      const isFromCaller = msg.role === "caller";
+      const targetPc = isFromCaller
+        ? this.incomingScreenPcs.get(pcKey)
+        : this.directScreenPcs.get(pcKey);
+      const queueKey = `${pcKey}:${isFromCaller ? "callee" : "caller"}`;
+
+      if (targetPc && targetPc.remoteDescription) {
+        await targetPc.addIceCandidate(new RTCIceCandidate(msg.candidate)).catch(() => {});
+      } else {
+        if (!this.pendingScreenIce.has(queueKey)) {
+          this.pendingScreenIce.set(queueKey, []);
+        }
+        this.pendingScreenIce.get(queueKey).push(msg.candidate);
+      }
+    }
+  }
+
+  getLocalUserMediaStream() {
+    const tracks = [];
+    const micPub = this.localParticipant.getTrackPublication(TrackSources.Microphone);
+    const camPub = this.localParticipant.getTrackPublication(TrackSources.Camera);
+
+    if (micPub?.track?.mediaStreamTrack && micPub.track.mediaStreamTrack.readyState === "live") {
+      tracks.push(micPub.track.mediaStreamTrack);
+    }
+    if (
+      camPub?.track?.mediaStreamTrack &&
+      !camPub.isMuted &&
+      camPub.track.mediaStreamTrack.readyState === "live"
+    ) {
+      tracks.push(camPub.track.mediaStreamTrack);
+    }
+    return tracks.length > 0 ? new MediaStream(tracks) : null;
+  }
+
+  getLocalScreenMediaStream() {
+    const scrPub = this.localParticipant.getTrackPublication(TrackSources.ScreenShare);
+    if (
+      scrPub?.track?.mediaStreamTrack &&
+      !scrPub.isMuted &&
+      scrPub.track.mediaStreamTrack.readyState === "live"
+    ) {
+      return new MediaStream([scrPub.track.mediaStreamTrack]);
+    }
+    return null;
+  }
+
+  patchMediaConnectionNegotiator(call) {
+    const neg = call?._negotiator;
+    if (!neg || neg._lmPatched) return;
+    neg._lmPatched = true;
+
+    let sdpChain = Promise.resolve();
+    const origHandleSDP = neg.handleSDP.bind(neg);
+    const origHandleCandidate = neg.handleCandidate.bind(neg);
+
+    neg.handleSDP = (type, sdp) => {
+      sdpChain = sdpChain
+        .then(() => origHandleSDP(type, sdp))
+        .catch(() => {});
+      return sdpChain;
+    };
+
+    neg.handleCandidate = (candidate) => {
+      sdpChain = sdpChain
+        .then(async () => {
+          const pc = call.peerConnection;
+          if (pc && !pc.remoteDescription) {
+            for (let i = 0; i < 20 && !pc.remoteDescription; i++) {
+              await new Promise((r) => setTimeout(r, 25));
+            }
+          }
+          if (pc && pc.signalingState !== "closed") {
+            return origHandleCandidate(candidate);
+          }
+        })
+        .catch(() => {});
+      return sdpChain;
+    };
+  }
+
+  callAllPeersScreenShare() {
+    const screenStream = this.getLocalScreenMediaStream();
+    if (!screenStream) return;
+
+    const dialedIdentities = new Set();
+    for (const p of this.remoteParticipants.values()) {
+      if (p.permissions?.canSubscribe && p.identity && !dialedIdentities.has(p.identity)) {
+        dialedIdentities.add(p.identity);
+        this.startDirectScreenShareToPeer(p.identity);
+        if (p.peerId) {
+          const peerIdCopy = p.peerId;
+          const idCopy = p.identity;
+          setTimeout(() => {
+            if (this.isDisconnected || !this.getLocalScreenMediaStream()) return;
+            const pc = this.directScreenPcs.get(`${idCopy}:screen`);
+            const connected =
+              pc &&
+              (pc.connectionState === "connected" ||
+                pc.iceConnectionState === "connected" ||
+                pc.iceConnectionState === "completed");
+            if (!connected) {
+              this.callPeerScreenShare(peerIdCopy, idCopy);
+            }
+          }, 3200);
+        }
+      }
+    }
+
+    if (!this.isHost && dialedIdentities.size === 0) {
+      this.startDirectScreenShareToPeer("host");
+    }
+  }
+
+  callPeerScreenShare(remotePeerId, remoteIdentity) {
+    if (!this.peer || !remotePeerId) return;
+    const screenStream = this.getLocalScreenMediaStream();
+    if (!screenStream) return;
+
+    const scrKey = `${remoteIdentity}:screen`;
+    const prevCall = this.activeMediaCalls.get(scrKey);
+    if (prevCall) {
+      try {
+        prevCall.close();
+      } catch {}
+      this.activeMediaCalls.delete(scrKey);
+    }
+
+    const scrCall = this.peer.call(remotePeerId, screenStream, {
+      metadata: {
+        identity: this.localParticipant.identity,
+        name: this.localParticipant.name,
+        streamKind: "screen",
+      },
+    });
+    if (scrCall) {
+      this.patchMediaConnectionNegotiator(scrCall);
+      this.bindMediaCallEvents(scrCall, remoteIdentity, "screen");
+      this.activeMediaCalls.set(scrKey, scrCall);
+    }
+  }
+
+  callPeerWithLocalTracks(remotePeerId, remoteIdentity, forceScreen = false) {
+    if (!this.peer || !remotePeerId) return;
+
+    const userStream = this.getLocalUserMediaStream();
+    if (userStream) {
+      const callKey = `${remoteIdentity}:user`;
+      const existingUserCall = this.activeMediaCalls.get(callKey);
+      const pc = existingUserCall?.peerConnection;
+      const isCallAlive = Boolean(
+        existingUserCall?.open &&
+          pc &&
+          pc.connectionState !== "closed" &&
+          pc.connectionState !== "failed" &&
+          pc.iceConnectionState !== "closed" &&
+          pc.iceConnectionState !== "failed"
+      );
+
+      let replacedInPlace = false;
+      if (isCallAlive && typeof pc.getSenders === "function") {
+        const senders = pc.getSenders();
+        const newAudio = userStream.getAudioTracks()[0] || null;
+        const newVideo = userStream.getVideoTracks()[0] || null;
+        const audioSender = senders.find((s) => s.track?.kind === "audio");
+        const videoSender = senders.find((s) => s.track?.kind === "video");
+
+        const canReplaceAudio = !newAudio || Boolean(audioSender);
+        const canReplaceVideo = !newVideo || Boolean(videoSender);
+        if (canReplaceAudio && canReplaceVideo) {
+          if (audioSender && newAudio) audioSender.replaceTrack(newAudio).catch(() => {});
+          if (videoSender) videoSender.replaceTrack(newVideo).catch(() => {});
+          replacedInPlace = true;
+        }
+      }
+
+      if (!replacedInPlace) {
+        if (existingUserCall) {
+          try {
+            existingUserCall.close();
+          } catch {}
+        }
+        const call = this.peer.call(remotePeerId, userStream, {
+          metadata: {
+            identity: this.localParticipant.identity,
+            name: this.localParticipant.name,
+            streamKind: "user",
+          },
+        });
+        if (call) {
+          this.patchMediaConnectionNegotiator(call);
+          this.bindMediaCallEvents(call, remoteIdentity, "user");
+          this.activeMediaCalls.set(callKey, call);
+        }
+      }
+    }
+
+    if (forceScreen && this.getLocalScreenMediaStream()) {
+      this.startDirectScreenShareToPeer(remoteIdentity);
+    }
+  }
+
+  closeOutgoingScreenCalls() {
+    for (const [key, call] of this.activeMediaCalls.entries()) {
+      if (key.endsWith(":screen")) {
+        try {
+          call.close();
+        } catch {}
+        this.activeMediaCalls.delete(key);
+      }
+    }
+    for (const [key, pc] of this.directScreenPcs.entries()) {
+      if (key.endsWith(":screen") || !key.includes(":")) {
+        try {
+          pc.close();
+        } catch {}
+        this.directScreenPcs.delete(key);
+      }
+    }
+  }
+
+  handleIncomingMediaCall(call) {
+    const meta = call.metadata || {};
+    const remoteIdentity = meta.identity || "";
+    const streamKind = meta.streamKind || "user";
+
+    this.patchMediaConnectionNegotiator(call);
+    this.bindMediaCallEvents(call, remoteIdentity, streamKind);
+
+    const answerStream = streamKind === "user" ? this.getLocalUserMediaStream() : undefined;
+    try {
+      call.answer(answerStream || undefined);
+    } catch {}
+
+    if (call.remoteStream) {
+      this.processIncomingRemoteStream(call.remoteStream, remoteIdentity, streamKind, meta.name);
+    }
+  }
+
+  processIncomingRemoteStream(remoteStream, remoteIdentity, streamKind, fallbackName) {
+    if (!remoteIdentity || !remoteStream) return;
+    let participant = this.remoteParticipants.get(remoteIdentity);
+    if (!participant) {
+      participant = new HybridParticipant({
+        identity: remoteIdentity,
+        name: fallbackName || "Participante",
+        metadata: JSON.stringify({ role: "guest", status: "approved" }),
+        permissions: { canPublish: true, canSubscribe: true, canPublishData: true },
+        isLocal: false,
+        room: this,
+      });
+      this.remoteParticipants.set(remoteIdentity, participant);
+    }
+
+    if (streamKind === "screen") {
+      const vTrack = remoteStream.getVideoTracks()[0];
+      if (vTrack) {
+        this.attachRemoteTrackToParticipant(
+          participant,
+          vTrack,
+          TrackKinds.Video,
+          TrackSources.ScreenShare
+        );
+      }
+      return;
+    }
+
+    for (const aTrack of remoteStream.getAudioTracks()) {
+      this.attachRemoteTrackToParticipant(
+        participant,
+        aTrack,
+        TrackKinds.Audio,
+        TrackSources.Microphone
+      );
+    }
+    for (const vTrack of remoteStream.getVideoTracks()) {
+      this.attachRemoteTrackToParticipant(
+        participant,
+        vTrack,
+        TrackKinds.Video,
+        TrackSources.Camera
+      );
+    }
+  }
+
+  bindMediaCallEvents(call, remoteIdentity, streamKind) {
+    const fallbackName = call.metadata?.name || "Participante";
+    call.on("stream", (remoteStream) => {
+      this.processIncomingRemoteStream(remoteStream, remoteIdentity, streamKind, fallbackName);
+    });
+  }
+
+  attachRemoteTrackToParticipant(participant, mediaStreamTrack, kind, source) {
+    if (!participant || !mediaStreamTrack) return;
+
+    if (!mediaStreamTrack._lmUnmuteBound) {
+      mediaStreamTrack._lmUnmuteBound = true;
+      mediaStreamTrack.addEventListener("unmute", () => {
+        const curPub = participant.getTrackPublication(source);
+        const curTrack = curPub?.track?.mediaStreamTrack;
+        if (!curTrack || curTrack.readyState === "ended" || curTrack.muted) {
+          if (curTrack?.id !== mediaStreamTrack.id) {
+            this.attachRemoteTrackToParticipant(participant, mediaStreamTrack, kind, source);
+            return;
+          }
+        }
+        if (curPub && curTrack?.id === mediaStreamTrack.id) {
+          curPub.isMuted = false;
+          for (const el of curPub.track.attachedElements) {
+            el.play?.().catch(() => {});
+          }
+          this.emit(RoomEvents.TrackUnmuted, curPub, participant);
+        }
+      });
+    }
+
+    const existingPub = participant.getTrackPublication(source);
+    if (existingPub?.track?.mediaStreamTrack?.id === mediaStreamTrack.id) {
+      return;
+    }
+
+    if (
+      existingPub?.track?.mediaStreamTrack &&
+      existingPub.track.mediaStreamTrack.readyState === "live" &&
+      mediaStreamTrack.muted
+    ) {
+      return;
+    }
+
+    if (existingPub?.track) {
+      existingPub.track.detach().forEach((el) => el.remove());
+    }
+
+    const hTrack = new HybridTrack(mediaStreamTrack, kind, source);
+    const pub = new HybridPublication({
+      trackSid: `${source}_${participant.identity}`,
+      source,
+      track: hTrack,
+      isMuted: false,
+    });
+    participant.setPublication(source, pub);
+
+    this.emit(RoomEvents.TrackSubscribed, hTrack, pub, participant);
+  }
+
+  // ============================================================================
+  // TRANSPORTE CLOUDFLARE CALLS SFU
+  // ============================================================================
+  async initCloudflareCallsSession() {
+    if (this.cfSessionId && this.cfPc) return;
+    if (this.cfInitPromise) return this.cfInitPromise;
+
+    this.cfInitPromise = (async () => {
+      const res = await this.apiPost("/api/cf-calls/session", {
+        room_hash: this.roomHash,
+      });
+      if (!res?.sessionId) {
+        throw new Error("No se recibió sessionId de Cloudflare Calls.");
+      }
+      this.cfSessionId = res.sessionId;
+      this.localParticipant.cfSessionId = res.sessionId;
+
+      this.cfPc = new RTCPeerConnection({
+        iceServers: this.iceServers,
+        bundlePolicy: "max-bundle",
+      });
+
+      this.cfPc.ontrack = (event) => {
+        const mid = event.transceiver?.mid;
+        const meta =
+          mid !== null && mid !== undefined ? this.cfMidToRemoteMeta.get(String(mid)) : null;
+        if (!meta) return;
+        this.attachCloudflareRemoteTrack(meta, event.track);
+      };
+    })();
+
+    try {
+      await this.cfInitPromise;
+    } catch (err) {
+      this.cfInitPromise = null;
+      throw err;
+    }
+  }
+
+  attachCloudflareRemoteTrack(meta, mediaStreamTrack) {
+    if (!meta || !mediaStreamTrack) return;
+    const participant = this.remoteParticipants.get(meta.identity);
+    if (!participant) return;
+
+    if (meta.trackName === "mic") {
+      this.attachRemoteTrackToParticipant(
+        participant,
+        mediaStreamTrack,
+        TrackKinds.Audio,
+        TrackSources.Microphone
+      );
+    } else if (meta.trackName === "cam") {
+      this.attachRemoteTrackToParticipant(
+        participant,
+        mediaStreamTrack,
+        TrackKinds.Video,
+        TrackSources.Camera
+      );
+    } else if (meta.trackName === "screen" || meta.trackName.startsWith("screen_")) {
+      this.attachRemoteTrackToParticipant(
+        participant,
+        mediaStreamTrack,
+        TrackKinds.Video,
+        TrackSources.ScreenShare
+      );
+    }
+  }
+
+  enqueueCfNegotiation(taskFn) {
+    this.cfNegotiationChain = this.cfNegotiationChain.then(taskFn, taskFn);
+    return this.cfNegotiationChain;
+  }
+
+  async pushLocalTracksToCloudflare() {
+    await this.initCloudflareCallsSession();
+    return this.enqueueCfNegotiation(async () => {
+      if (!this.cfPc || !this.cfSessionId) return;
+
+      const screenKey = this.currentScreenTrackName || "screen";
+      const sourceMap = [
+        { key: "mic", source: TrackSources.Microphone },
+        { key: "cam", source: TrackSources.Camera },
+        { key: screenKey, source: TrackSources.ScreenShare },
+      ];
+
+      const newTracksToPush = [];
+      const activeNames = [];
+
+      for (const { key, source } of sourceMap) {
+        const pub = this.localParticipant.getTrackPublication(source);
+        const mediaTrack = pub?.track?.mediaStreamTrack;
+        const isLive = Boolean(mediaTrack && !pub.isMuted && mediaTrack.readyState === "live");
+
+        if (isLive) {
+          activeNames.push(key);
+          const existingTransceiver = this.cfTransceivers.get(key);
+          if (existingTransceiver) {
+            await existingTransceiver.sender.replaceTrack(mediaTrack);
+          } else {
+            const tr = this.cfPc.addTransceiver(mediaTrack, { direction: "sendonly" });
+            this.cfTransceivers.set(key, tr);
+            newTracksToPush.push({ key, tr });
+          }
+        }
+      }
+
+      if (newTracksToPush.length > 0) {
+        const offer = await this.cfPc.createOffer();
+        await this.cfPc.setLocalDescription(offer);
+
+        const tracksPayload = newTracksToPush.map(({ key, tr }) => ({
+          location: "local",
+          mid: tr.mid,
+          trackName: key,
+        }));
+
+        const data = await this.apiPost("/api/cf-calls/tracks-new", {
+          room_hash: this.roomHash,
+          sessionId: this.cfSessionId,
+          sessionDescription: {
+            sdp: offer.sdp,
+            type: "offer",
+          },
+          tracks: tracksPayload,
+        });
+
+        if (data?.sessionDescription) {
+          await this.cfPc.setRemoteDescription(
+            new RTCSessionDescription(data.sessionDescription)
+          );
+        }
+      }
+
+      this.localParticipant.cfPublishedTracks = activeNames;
+    });
+  }
+
+  async pullRemoteTracksFromCloudflare(remoteParticipant) {
+    if (!this.cfCallsReady || !remoteParticipant?.cfSessionId) return;
+    const remoteSessionId = remoteParticipant.cfSessionId;
+    const published = Array.isArray(remoteParticipant.cfPublishedTracks)
+      ? remoteParticipant.cfPublishedTracks
+      : [];
+
+    const tracksToPull = [];
+    for (const trackName of published) {
+      const pullKey = `${remoteSessionId}:${trackName}`;
+      if (!this.cfPulledRemoteKeys.has(pullKey)) {
+        this.cfPulledRemoteKeys.add(pullKey);
+        tracksToPull.push({
+          location: "remote",
+          sessionId: remoteSessionId,
+          trackName,
+        });
+      }
+    }
+
+    if (tracksToPull.length === 0) return;
+
+    await this.initCloudflareCallsSession();
+    return this.enqueueCfNegotiation(async () => {
+      if (!this.cfPc || !this.cfSessionId) return;
+      try {
+        const res = await this.apiPost("/api/cf-calls/tracks-new", {
+          room_hash: this.roomHash,
+          sessionId: this.cfSessionId,
+          tracks: tracksToPull,
+        });
+
+        let needsRetry = false;
+        if (Array.isArray(res?.tracks)) {
+          for (let i = 0; i < res.tracks.length; i++) {
+            const t = res.tracks[i];
+            const tName = t?.trackName || tracksToPull[i]?.trackName;
+            if (!tName) continue;
+            const pullKey = `${remoteSessionId}:${tName}`;
+
+            if (t && t.mid !== undefined && !t.errorCode) {
+              this.cfMidToRemoteMeta.set(String(t.mid), {
+                identity: remoteParticipant.identity,
+                trackName: tName,
+              });
+              this.cfPullRetryCounts.delete(pullKey);
+            } else {
+              this.cfPulledRemoteKeys.delete(pullKey);
+              const retries = (this.cfPullRetryCounts.get(pullKey) || 0) + 1;
+              if (retries <= 8) {
+                this.cfPullRetryCounts.set(pullKey, retries);
+                needsRetry = true;
+              }
+            }
+          }
+        }
+
+        if (res?.requiresImmediateRenegotiation && res?.sessionDescription) {
+          await this.cfPc.setRemoteDescription(
+            new RTCSessionDescription(res.sessionDescription)
+          );
+          const answer = await this.cfPc.createAnswer();
+          await this.cfPc.setLocalDescription(answer);
+
+          await this.apiPost("/api/cf-calls/renegotiate", {
+            room_hash: this.roomHash,
+            sessionId: this.cfSessionId,
+            sessionDescription: {
+              sdp: answer.sdp,
+              type: "answer",
+            },
+          });
+        }
+
+        for (const tr of this.cfPc.getTransceivers()) {
+          if (tr.mid !== null && tr.mid !== undefined && tr.receiver?.track) {
+            const meta = this.cfMidToRemoteMeta.get(String(tr.mid));
+            if (meta) {
+              this.attachCloudflareRemoteTrack(meta, tr.receiver.track);
+            }
+          }
+        }
+
+        if (needsRetry && !this.isDisconnected) {
+          setTimeout(() => {
+            if (!this.isDisconnected) {
+              this.pullRemoteTracksFromCloudflare(remoteParticipant);
+            }
+          }, 700);
+        }
+      } catch {
+        for (const t of tracksToPull) {
+          this.cfPulledRemoteKeys.delete(`${t.sessionId}:${t.trackName}`);
+        }
+      }
+    });
+  }
+
+  // ============================================================================
+  // ENVÍO DE DATOS CIFRADOS (E2EE)
+  // ============================================================================
+  async sendData(payload, options = {}) {
+    let text = "";
+    if (typeof payload === "string") {
+      text = payload;
+    } else if (payload instanceof Uint8Array || payload instanceof ArrayBuffer) {
+      text = new TextDecoder().decode(payload);
+    } else {
+      text = JSON.stringify(payload);
+    }
+
+    let cipher = null;
+    try {
+      cipher = await encryptDataPacket(this.roomHash, text);
+    } catch {
+      cipher = null;
+    }
+
+    const packet = {
+      type: "app_data",
+      senderId: this.localParticipant.identity,
+      senderName: this.localParticipant.name,
+      ...(cipher ? { cipher } : { text }),
+    };
+
+    if (this.isHost) {
+      for (const p of this.remoteParticipants.values()) {
+        if (p.permissions?.canSubscribe) {
+          this.enqueueHttpSignal(p.identity, packet);
+        }
+      }
+      for (const [id, conn] of this.guestConns.entries()) {
+        const gp = this.remoteParticipants.get(id);
+        if (conn.open && gp?.permissions?.canSubscribe) {
+          conn.send(packet);
+        }
+      }
+    } else {
+      this.enqueueHttpSignal("host", packet);
+      if (this.hostConn?.open) {
+        this.hostConn.send(packet);
+      }
+    }
+  }
+
+  async kickParticipant(identity) {
+    if (!this.isHost) return;
+    try {
+      await this.apiPost("/api/kick", {
+        room_hash: this.roomHash,
+        host_secret: this.hostSecret,
+        identity,
+      });
+    } catch {}
+
+    this.enqueueHttpSignal(identity, { type: "kicked" });
+    const conn = this.guestConns.get(identity);
+    const p = this.remoteParticipants.get(identity);
+    if (conn?.open) {
+      conn.send({ type: "kicked" });
+      setTimeout(() => conn.close(), 150);
+    }
+    this.guestConns.delete(identity);
+    if (p) {
+      this.cleanupRemoteParticipantTracks(p);
+      this.remoteParticipants.delete(identity);
+      this.emit(RoomEvents.ParticipantDisconnected, p);
+      this.broadcastRoster();
+    }
+  }
+
+  async muteParticipant(identity, trackSid = "") {
+    if (!this.isHost) return;
+    try {
+      if (trackSid) {
+        await this.apiPost("/api/mute", {
+          room_hash: this.roomHash,
+          host_secret: this.hostSecret,
+          identity,
+          track_sid: trackSid,
+        });
+      }
+    } catch {}
+
+    const payload = JSON.stringify({
+      type: "remote_mute",
+      targetIdentity: identity,
+      senderName: this.localParticipant.name,
+    });
+    await this.sendData(payload);
+  }
+
+  async endRoom() {
+    if (!this.isHost) return;
+    try {
+      this.enqueueHttpSignal("all", { type: "room_ended" });
+      for (const conn of this.guestConns.values()) {
+        if (conn.open) {
+          conn.send({ type: "room_ended" });
+        }
+      }
+      await this.apiPost("/api/end-room", {
+        room_hash: this.roomHash,
+        host_secret: this.hostSecret,
+      });
+    } catch {}
+    this.disconnect();
+  }
+
+  cleanupRemoteParticipantTracks(participant) {
+    for (const pub of participant.trackPublications.values()) {
+      if (pub.track) {
+        pub.track.detach().forEach((el) => el.remove());
+        this.emit(RoomEvents.TrackUnsubscribed, pub.track, pub, participant);
+      }
+    }
+    participant.trackPublications.clear();
+    participant.videoTrackPublications.clear();
+  }
+
+  disconnect() {
+    if (this.isDisconnected) return;
+    this.isDisconnected = true;
+
+    if (this.syncTimer) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+    if (this.peerKeepAliveTimer) {
+      clearInterval(this.peerKeepAliveTimer);
+      this.peerKeepAliveTimer = null;
+    }
+
+    for (const pub of this.localParticipant.trackPublications.values()) {
+      pub.track?.stop();
+      pub.track?.detach().forEach((el) => el.remove());
+    }
+    this.localParticipant.trackPublications.clear();
+    this.localParticipant.videoTrackPublications.clear();
+
+    for (const p of this.remoteParticipants.values()) {
+      this.cleanupRemoteParticipantTracks(p);
+    }
+    this.remoteParticipants.clear();
+
+    for (const call of this.activeMediaCalls.values()) {
+      try {
+        call.close();
+      } catch {}
+    }
+    this.activeMediaCalls.clear();
+
+    for (const pc of this.directScreenPcs.values()) {
+      try {
+        pc.close();
+      } catch {}
+    }
+    this.directScreenPcs.clear();
+
+    for (const pc of this.incomingScreenPcs.values()) {
+      try {
+        pc.close();
+      } catch {}
+    }
+    this.incomingScreenPcs.clear();
+    this.pendingScreenIce.clear();
+
+    try {
+      this.cfPc?.close();
+    } catch {}
+    this.cfPc = null;
+
+    try {
+      this.hostConn?.close();
+    } catch {}
+    for (const conn of this.guestConns.values()) {
+      try {
+        conn.close();
+      } catch {}
+    }
+    this.guestConns.clear();
+
+    try {
+      this.peer?.destroy();
+    } catch {}
+    this.peer = null;
+
+    this.emit(RoomEvents.Disconnected);
+  }
+}
+
+
+
+
+
+/**
+ * Cliente principal estilo Axios para inicializar llamadas con 1 sola línea de código.
+ */
+const LocalMeet = {
+  RoomEvents,
+  TrackSources,
+  TrackKinds,
+  EngineModes,
+  LocalMeetRoom,
+  HybridTrack,
+  HybridPublication,
+  HybridParticipant,
+
+  /**
+   * Crea una sala nueva como anfitrión en el backend y devuelve una instancia lista de LocalMeetRoom.
+   *
+   * @param {Object} options
+   * @param {string} options.serverUrl - URL del Worker o servidor de señalización (ej: "https://mi-meet.workers.dev")
+   * @param {string} [options.hostName="Anfitrión"] - Nombre a mostrar del anfitrión
+   * @param {string} [options.title=""] - Título de la reunión
+   * @param {string} [options.engine="cf-calls"] - "cf-calls" | "p2p" | "livekit"
+   * @param {string} [options.accessKey=""] - Clave HOST_ACCESS_KEY si el servidor la requiere
+   * @param {string} [options.customHash=""] - Hash de sala a reutilizar si ya eres el anfitrión
+   * @param {string} [options.hostSecret=""] - Secreto de anfitrión previo
+   * @returns {Promise<LocalMeetRoom>}
+   */
+  async createRoom(options = {}) {
+    const {
+      serverUrl = typeof window !== "undefined" ? window.location.origin : "",
+      hostName = "Anfitrión",
+      title = "",
+      engine = EngineModes.CloudflareCalls,
+      accessKey = "",
+      customHash = "",
+      hostSecret = "",
+      debug = false,
+    } = options;
+
+    const cleanServer = (serverUrl || "").replace(/\/+$/, "");
+    const res = await fetch(`${cleanServer}/api/host-join`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        host_name: hostName,
+        title,
+        engine,
+        access_key: accessKey,
+        room_hash: customHash,
+        host_secret: hostSecret,
+      }),
+    });
+
+    const data = await res.json();
+    if (!res.ok) {
+      throw new Error(data?.detail || `Error al crear sala (${res.status})`);
+    }
+
+    const room = new LocalMeetRoom({
+      serverUrl: cleanServer,
+      roomHash: data.room_hash,
+      title: data.title || title,
+      identity: data.identity,
+      displayName: data.host_name || hostName,
+      isHost: true,
+      hostSecret: data.host_secret,
+      engine: data.engine || engine,
+      cfCallsReady: Boolean(data.cf_calls_ready),
+      iceServers: data.ice_servers,
+      startInWaitingRoom: false,
+      debug,
+    });
+
+    return room;
+  },
+
+  /**
+   * Se une a una sala existente como invitado.
+   *
+   * @param {Object} options
+   * @param {string} options.serverUrl - URL del Worker o servidor
+   * @param {string} options.roomHash - Hash de la sala (ej: "c4f2-9k81-m3n2")
+   * @param {string} [options.guestName="Invitado"] - Nombre del participante
+   * @returns {Promise<LocalMeetRoom>}
+   */
+  async join(options = {}) {
+    const {
+      serverUrl = typeof window !== "undefined" ? window.location.origin : "",
+      roomHash = "",
+      guestName = "Invitado",
+      debug = false,
+    } = options;
+
+    const cleanServer = (serverUrl || "").replace(/\/+$/, "");
+    const cleanHash = (roomHash || "").toLowerCase().trim();
+
+    const res = await fetch(`${cleanServer}/api/guest-join`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        room_hash: cleanHash,
+        guest_name: guestName,
+      }),
+    });
+
+    const data = await res.json();
+    if (!res.ok) {
+      throw new Error(data?.detail || `Error al unirse a sala (${res.status})`);
+    }
+
+    const room = new LocalMeetRoom({
+      serverUrl: cleanServer,
+      roomHash: data.room_hash,
+      title: `Sala ${data.room_hash}`,
+      identity: data.identity,
+      displayName: data.guest_name || guestName,
+      isHost: false,
+      engine: data.engine || EngineModes.CloudflareCalls,
+      cfCallsReady: Boolean(data.cf_calls_ready),
+      iceServers: data.ice_servers,
+      startInWaitingRoom: true,
+      debug,
+    });
+
+    return room;
+  },
+};
+
+
+
+module.exports = LocalMeet;
+module.exports.default = LocalMeet;
+module.exports.LocalMeet = LocalMeet;
+module.exports.LocalMeetRoom = LocalMeetRoom;
+module.exports.HybridTrack = HybridTrack;
+module.exports.HybridPublication = HybridPublication;
+module.exports.HybridParticipant = HybridParticipant;
+module.exports.RoomEvents = RoomEvents;
+module.exports.TrackSources = TrackSources;
+module.exports.TrackKinds = TrackKinds;
+module.exports.EngineModes = EngineModes;
+module.exports.encryptDataPacket = encryptDataPacket;
+module.exports.decryptDataPacket = decryptDataPacket;