@livekit/rtc-node 0.13.31 → 0.13.33

package/dist/room.js

@@ -1,899 +0,0 @@
-import { Mutex } from "@livekit/mutex";
-import { EncryptionState } from "@livekit/rtc-ffi-bindings";
-import { DisconnectReason } from "@livekit/rtc-ffi-bindings";
-import {
-  ConnectRequest,
-  ConnectionState,
-  ContinualGatheringPolicy,
-  RoomOptions as FfiRoomOptions,
-  IceTransportType
-} from "@livekit/rtc-ffi-bindings";
-import { TrackKind } from "@livekit/rtc-ffi-bindings";
-import EventEmitter from "events";
-import { ByteStreamReader, TextStreamReader } from "./data_streams/stream_reader.js";
-import { E2EEManager, defaultE2EEOptions } from "./e2ee.js";
-import { FfiClient, FfiClientEvent, FfiHandle } from "./ffi_client.js";
-import { log } from "./log.js";
-import { LocalParticipant, RemoteParticipant } from "./participant.js";
-import { RemoteAudioTrack, RemoteVideoTrack } from "./track.js";
-import { RemoteTrackPublication } from "./track_publication.js";
-import { bigIntToNumber } from "./utils.js";
-const defaultRtcConfiguration = {
-  iceTransportType: IceTransportType.TRANSPORT_ALL,
-  continualGatheringPolicy: ContinualGatheringPolicy.GATHER_CONTINUALLY,
-  iceServers: []
-};
-const defaultRoomOptions = new FfiRoomOptions({
-  autoSubscribe: true,
-  dynacast: false,
-  e2ee: void 0,
-  encryption: void 0,
-  rtcConfig: void 0,
-  adaptiveStream: false,
-  joinRetries: 1
-});
-class Room extends EventEmitter {
-  constructor() {
-    super();
-    /**
-     * used to ensure events are processed sequentially and allow for
-     * the local participant to acquire the lock while doing state updates related to FFI events
-     * before processing the next events
-     */
-    this.ffiEventLock = new Mutex();
-    this.byteStreamControllers = /* @__PURE__ */ new Map();
-    this.textStreamControllers = /* @__PURE__ */ new Map();
-    this.byteStreamHandlers = /* @__PURE__ */ new Map();
-    this.textStreamHandlers = /* @__PURE__ */ new Map();
-    this.preConnectEvents = [];
-    // Aborted on disconnect to cancel any pending FfiClient.waitFor() listeners,
-    // preventing them from leaking when the room goes away.
-    this.disconnectController = new AbortController();
-    // Guards cleanupOnDisconnect so the ConnectionStateChanged/Disconnected
-    // events fire exactly once, no matter which path (explicit disconnect()
-    // vs. FFI 'disconnected' event) wins the race.
-    this.hasCleanedUp = false;
-    this._connectionState = ConnectionState.CONN_DISCONNECTED;
-    this.remoteParticipants = /* @__PURE__ */ new Map();
-    this.onFfiEvent = async (ffiEvent) => {
-      const unlock = await this.ffiEventLock.lock();
-      try {
-        if (!this.localParticipant || !this.ffiHandle || !this.info) {
-          this.preConnectEvents.push(ffiEvent);
-          return;
-        }
-        for (const ev of this.preConnectEvents) {
-          await this.processFfiEvent(ev);
-        }
-        this.preConnectEvents = [];
-        await this.processFfiEvent(ffiEvent);
-      } finally {
-        unlock();
-      }
-    };
-    this.processFfiEvent = async (ffiEvent) => {
-      var _a, _b;
-      if (!this.localParticipant || !this.ffiHandle || !this.info) {
-        throw new Error("processFfiEvent called before connect");
-      }
-      if (ffiEvent.message.case == "rpcMethodInvocation") {
-        if (ffiEvent.message.value.localParticipantHandle == this.localParticipant.ffi_handle.handle) {
-          this.localParticipant.handleRpcMethodInvocation(
-            ffiEvent.message.value.invocationId,
-            ffiEvent.message.value.method,
-            ffiEvent.message.value.requestId,
-            ffiEvent.message.value.callerIdentity,
-            ffiEvent.message.value.payload,
-            ffiEvent.message.value.responseTimeoutMs
-          );
-        }
-        return;
-      } else if (ffiEvent.message.case != "roomEvent" || ffiEvent.message.value.roomHandle != this.ffiHandle.handle) {
-        return;
-      }
-      const ev = ffiEvent.message.value.message;
-      if (process.env.LIVEKIT_DEBUG_LOG_ROOM_EVENTS) {
-        console.log("Room event:", ev);
-      }
-      if (ev.case == "participantConnected") {
-        const participant = this.createRemoteParticipant(ev.value.info);
-        this.remoteParticipants.set(participant.identity, participant);
-        this.emit("participantConnected" /* ParticipantConnected */, participant);
-      } else if (ev.case == "participantDisconnected") {
-        const participant = this.remoteParticipants.get(ev.value.participantIdentity);
-        if (participant) {
-          this.remoteParticipants.delete(participant.identity);
-          participant.info.disconnectReason = ev.value.disconnectReason;
-          this.emit("participantDisconnected" /* ParticipantDisconnected */, participant);
-        } else {
-          log.warn(`RoomEvent.ParticipantDisconnected: Could not find participant`);
-        }
-      } else if (ev.case == "localTrackPublished") {
-        const publication = this.localParticipant.trackPublications.get(ev.value.trackSid);
-        if (publication == null ? void 0 : publication.track) {
-          publication.track.setRoom(this);
-        }
-        this.emit("localTrackPublished" /* LocalTrackPublished */, publication, this.localParticipant);
-      } else if (ev.case == "localTrackUnpublished") {
-        const publication = this.localParticipant.trackPublications.get(ev.value.publicationSid);
-        const track = publication == null ? void 0 : publication.track;
-        if (track) {
-          track.setRoom(null);
-        }
-        this.localParticipant.trackPublications.delete(ev.value.publicationSid);
-        this.emit("localTrackUnpublished" /* LocalTrackUnpublished */, publication, this.localParticipant);
-        if (track && publication) {
-          publication.track = void 0;
-        }
-      } else if (ev.case == "localTrackRepublished") {
-        const value = ev.value;
-        const previousSid = value.previousSid;
-        const newInfo = value.info;
-        const publication = this.localParticipant.trackPublications.get(previousSid);
-        if (publication) {
-          publication.updateInfo(newInfo);
-          this.localParticipant.trackPublications.delete(previousSid);
-          this.localParticipant.trackPublications.set(publication.sid, publication);
-          if ((_a = publication.track) == null ? void 0 : _a.info) {
-            publication.track.info.sid = publication.sid;
-            publication.track.setRoom(this);
-          }
-          this.emit("localTrackRepublished" /* LocalTrackRepublished */, publication, previousSid, this.localParticipant);
-        } else {
-          log.warn(`RoomEvent.LocalTrackRepublished: previous publication not found: ${previousSid}`);
-        }
-      } else if (ev.case == "localTrackSubscribed") {
-        const publication = this.localParticipant.trackPublications.get(ev.value.trackSid);
-        if (publication) {
-          publication.resolveFirstSubscription();
-          this.emit("localTrackSubscribed" /* LocalTrackSubscribed */, publication.track);
-        } else {
-          log.warn(`RoomEvent.LocalTrackSubscribed: Publication not found: ${ev.value.trackSid}`);
-        }
-      } else if (ev.case == "trackPublished") {
-        const participant = this.remoteParticipants.get(ev.value.participantIdentity);
-        const publication = new RemoteTrackPublication(ev.value.publication);
-        if (participant) {
-          participant.trackPublications.set(publication.sid, publication);
-        } else {
-          log.warn(
-            `RoomEvent.TrackPublished: Could not find participant: ${ev.value.participantIdentity}`
-          );
-        }
-        this.emit("trackPublished" /* TrackPublished */, publication, participant);
-      } else if (ev.case == "trackUnpublished") {
-        const participant = this.requireRemoteParticipant(ev.value.participantIdentity);
-        const publication = participant.trackPublications.get(ev.value.publicationSid);
-        participant.trackPublications.delete(ev.value.publicationSid);
-        if (publication) {
-          this.emit("trackUnpublished" /* TrackUnpublished */, publication, participant);
-          publication.ffiHandle.dispose();
-        } else {
-          log.warn(`RoomEvent.TrackUnpublished: Could not find publication`);
-        }
-      } else if (ev.case == "trackSubscribed") {
-        const ownedTrack = ev.value.track;
-        const trackInfo = ownedTrack.info;
-        try {
-          const { participant, publication } = this.requirePublicationOfRemoteParticipant(
-            ev.value.participantIdentity,
-            trackInfo.sid
-          );
-          publication.subscribed = true;
-          if (trackInfo.kind == TrackKind.KIND_VIDEO) {
-            publication.track = new RemoteVideoTrack(ownedTrack);
-          } else if (trackInfo.kind == TrackKind.KIND_AUDIO) {
-            publication.track = new RemoteAudioTrack(ownedTrack);
-          }
-          (_b = publication.track) == null ? void 0 : _b.setRoom(this);
-          this.emit("trackSubscribed" /* TrackSubscribed */, publication.track, publication, participant);
-        } catch (e) {
-          log.warn(`RoomEvent.TrackSubscribed: ${e.message}`);
-        }
-      } else if (ev.case == "trackUnsubscribed") {
-        try {
-          const { participant, publication } = this.requirePublicationOfRemoteParticipant(
-            ev.value.participantIdentity,
-            ev.value.trackSid
-          );
-          const track = publication.track;
-          track.setRoom(null);
-          publication.track = void 0;
-          publication.subscribed = false;
-          this.emit("trackUnsubscribed" /* TrackUnsubscribed */, track, publication, participant);
-        } catch (e) {
-          log.warn(`RoomEvent.TrackUnsubscribed: ${e.message}`);
-        }
-      } else if (ev.case == "trackSubscriptionFailed") {
-        try {
-          const participant = this.requireRemoteParticipant(ev.value.participantIdentity);
-          this.emit(
-            "trackSubscriptionFailed" /* TrackSubscriptionFailed */,
-            ev.value.trackSid,
-            participant,
-            ev.value.error
-          );
-        } catch (e) {
-          log.warn(`RoomEvent.TrackSubscriptionFailed: ${e.message}`);
-        }
-      } else if (ev.case == "trackMuted") {
-        try {
-          const { participant, publication } = this.requirePublicationOfParticipant(
-            ev.value.participantIdentity,
-            ev.value.trackSid
-          );
-          publication.info.muted = true;
-          if (publication.track) {
-            publication.track.info.muted = true;
-          }
-          this.emit("trackMuted" /* TrackMuted */, publication, participant);
-        } catch (e) {
-          log.warn(`RoomEvent.TrackMuted: ${e.message}`);
-        }
-      } else if (ev.case == "trackUnmuted") {
-        try {
-          const { participant, publication } = this.requirePublicationOfParticipant(
-            ev.value.participantIdentity,
-            ev.value.trackSid
-          );
-          publication.info.muted = false;
-          if (publication.track) {
-            publication.track.info.muted = false;
-          }
-          this.emit("trackUnmuted" /* TrackUnmuted */, publication, participant);
-        } catch (e) {
-          log.warn(`RoomEvent.TrackUnmuted: ${e.message}`);
-        }
-      } else if (ev.case == "activeSpeakersChanged") {
-        try {
-          const activeSpeakers = ev.value.participantIdentities.map(
-            (identity) => this.requireParticipantByIdentity(identity)
-          );
-          this.emit("activeSpeakersChanged" /* ActiveSpeakersChanged */, activeSpeakers);
-        } catch (e) {
-          log.warn(`RoomEvent.ActiveSpeakersChanged: ${e.message}`);
-        }
-      } else if (ev.case == "roomMetadataChanged") {
-        this.info.metadata = ev.value.metadata ?? "";
-        this.emit("roomMetadataChanged" /* RoomMetadataChanged */, this.info.metadata);
-      } else if (ev.case == "participantMetadataChanged") {
-        try {
-          const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
-          participant.info.metadata = ev.value.metadata;
-          this.emit("participantMetadataChanged" /* ParticipantMetadataChanged */, participant.metadata, participant);
-        } catch (e) {
-          log.warn(`RoomEvent.ParticipantMetadataChanged: ${e.message}`);
-        }
-      } else if (ev.case == "participantNameChanged") {
-        try {
-          const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
-          participant.info.name = ev.value.name;
-          this.emit("participantNameChanged" /* ParticipantNameChanged */, participant.name, participant);
-        } catch (e) {
-          log.warn(`RoomEvent.ParticipantNameChanged: ${e.message}`);
-        }
-      } else if (ev.case == "participantAttributesChanged") {
-        try {
-          const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
-          participant.info.attributes = ev.value.attributes.reduce(
-            (acc, value) => {
-              acc[value.key] = value.value;
-              return acc;
-            },
-            {}
-          );
-          if (Object.keys(ev.value.changedAttributes).length > 0) {
-            const changedAttributes = ev.value.changedAttributes.reduce(
-              (acc, value) => {
-                acc[value.key] = value.value;
-                return acc;
-              },
-              {}
-            );
-            this.emit("participantAttributesChanged" /* ParticipantAttributesChanged */, changedAttributes, participant);
-          }
-        } catch (e) {
-          log.warn(`RoomEvent.ParticipantAttributesChanged: ${e.message}`);
-        }
-      } else if (ev.case == "connectionQualityChanged") {
-        try {
-          const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
-          this.emit("connectionQualityChanged" /* ConnectionQualityChanged */, ev.value.quality, participant);
-        } catch (e) {
-          log.warn(`RoomEvent.ConnectionQualityChanged: ${e.message}`);
-        }
-      } else if (ev.case == "chatMessage") {
-        const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity);
-        const { id, message: messageText, timestamp, editTimestamp, generated } = ev.value.message;
-        const message = {
-          id,
-          message: messageText,
-          timestamp: Number(timestamp),
-          editTimestamp: Number(editTimestamp),
-          generated
-        };
-        this.emit("chatMessage" /* ChatMessage */, message, participant);
-      } else if (ev.case == "dataPacketReceived") {
-        const participant = this.remoteParticipants.get(ev.value.participantIdentity);
-        const dataPacket = ev.value.value;
-        switch (dataPacket.case) {
-          case "user":
-            const buffer = FfiClient.instance.copyBuffer(
-              dataPacket.value.data.data.dataPtr,
-              Number(dataPacket.value.data.data.dataLen)
-            );
-            new FfiHandle(dataPacket.value.data.handle.id).dispose();
-            this.emit(
-              "dataReceived" /* DataReceived */,
-              buffer,
-              participant,
-              ev.value.kind,
-              dataPacket.value.topic
-            );
-            break;
-          case "sipDtmf":
-            const { code, digit } = dataPacket.value;
-            this.emit("dtmfReceived" /* DtmfReceived */, code, digit, participant);
-            break;
-          default:
-            break;
-        }
-      } else if (ev.case == "e2eeStateChanged") {
-        if (ev.value.state == EncryptionState.INTERNAL_ERROR) {
-          this.emit("encryptionError" /* EncryptionError */, new Error("internal server error"));
-        }
-      } else if (ev.case == "connectionStateChanged") {
-        this.updateConnectionState(ev.value.state);
-      } else if (ev.case == "disconnected") {
-        this.cleanupOnDisconnect(ev.value.reason);
-      } else if (ev.case == "reconnecting") {
-        this.emit("reconnecting" /* Reconnecting */);
-      } else if (ev.case == "reconnected") {
-        this.emit("reconnected" /* Reconnected */);
-      } else if (ev.case == "roomSidChanged") {
-        this.emit("roomSidChanged" /* RoomSidChanged */, ev.value.sid);
-      } else if (ev.case === "streamHeaderReceived" && ev.value.header) {
-        this.handleStreamHeader(ev.value.header, ev.value.participantIdentity);
-      } else if (ev.case === "streamChunkReceived" && ev.value.chunk) {
-        this.handleStreamChunk(ev.value.chunk);
-      } else if (ev.case === "streamTrailerReceived" && ev.value.trailer) {
-        this.handleStreamTrailer(ev.value.trailer);
-      } else if (ev.case === "roomUpdated") {
-        this.info = ev.value;
-        this.emit("roomUpdated" /* RoomUpdated */);
-      } else if (ev.case === "moved") {
-        this.info = ev.value;
-        this.emit("moved" /* Moved */);
-      } else if (ev.case === "participantsUpdated") {
-        for (const info of ev.value.participants) {
-          const participant = this.retrieveParticipantByIdentity(info.identity);
-          if (participant) {
-            participant.info = info;
-          }
-        }
-      } else if (ev.case === "participantEncryptionStatusChanged") {
-        try {
-          const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
-          this.emit(
-            "participantEncryptionStatusChanged" /* ParticipantEncryptionStatusChanged */,
-            !!ev.value.isEncrypted,
-            participant
-          );
-        } catch (e) {
-          log.warn(`RoomEvent.ParticipantEncryptionStatusChanged: ${e.message}`);
-        }
-      } else if (ev.case === "tokenRefreshed") {
-        this._token = ev.value.token;
-        this.emit("tokenRefreshed");
-      }
-    };
-  }
-  get connectionState() {
-    return this._connectionState;
-  }
-  get name() {
-    var _a;
-    return (_a = this.info) == null ? void 0 : _a.name;
-  }
-  get metadata() {
-    var _a;
-    return (_a = this.info) == null ? void 0 : _a.metadata;
-  }
-  get isConnected() {
-    return this.ffiHandle != void 0 && this.connectionState != ConnectionState.CONN_DISCONNECTED;
-  }
-  /** @internal */
-  get token() {
-    return this._token;
-  }
-  /** @internal */
-  get serverUrl() {
-    return this._serverUrl;
-  }
-  /**
-   * Gets the room's server ID. This ID is assigned by the LiveKit server
-   * and is unique for each room session.
-   * SID is assigned asynchronously after connection.
-   * @returns Promise that resolves to the room's server ID, or empty string if not connected
-   */
-  async getSid() {
-    var _a;
-    if (!this.isConnected) {
-      return "";
-    }
-    if (((_a = this.info) == null ? void 0 : _a.sid) && this.info.sid !== "") {
-      return this.info.sid;
-    }
-    if (!this.sidPromise) {
-      this.sidPromise = new Promise((resolve, reject) => {
-        const handleDisconnect = () => {
-          this.off("roomSidChanged" /* RoomSidChanged */, handleRoomUpdate);
-          this.sidPromise = void 0;
-          reject("Room disconnected before room server id was available");
-        };
-        const handleRoomUpdate = (sid) => {
-          if (sid !== "") {
-            this.off("roomSidChanged" /* RoomSidChanged */, handleRoomUpdate);
-            this.off("disconnected" /* Disconnected */, handleDisconnect);
-            this.sidPromise = void 0;
-            resolve(sid);
-          }
-        };
-        this.on("roomSidChanged" /* RoomSidChanged */, handleRoomUpdate);
-        this.once("disconnected" /* Disconnected */, handleDisconnect);
-      });
-    }
-    return this.sidPromise;
-  }
-  async getRtcStats() {
-    if (!this.isConnected || !this.ffiHandle) {
-      throw new Error("getRtcStats requires a connected room");
-    }
-    const requestId = FfiClient.instance.getNextRequestAsyncId();
-    const cbPromise = FfiClient.instance.waitFor(
-      (ev) => ev.message.case === "getSessionStats" && ev.message.value.asyncId === requestId,
-      { signal: this.disconnectController.signal }
-    );
-    FfiClient.instance.request({
-      message: {
-        case: "getSessionStats",
-        value: {
-          roomHandle: this.ffiHandle.handle,
-          requestAsyncId: requestId
-        }
-      }
-    });
-    const cb = await cbPromise;
-    if (cb.message.case === "error") {
-      throw new Error(cb.message.value);
-    } else if (cb.message.case === "result") {
-      return cb.message.value;
-    } else {
-      throw new Error("could not retrieve rtc stats");
-    }
-  }
-  get numParticipants() {
-    var _a;
-    return ((_a = this.info) == null ? void 0 : _a.numParticipants) ?? 0;
-  }
-  get numPublishers() {
-    var _a;
-    return ((_a = this.info) == null ? void 0 : _a.numPublishers) ?? 0;
-  }
-  get creationTime() {
-    var _a;
-    let creationTimeMs = Number(((_a = this.info) == null ? void 0 : _a.creationTime) ?? 0);
-    if (creationTimeMs > 0 && creationTimeMs < 1e12) {
-      creationTimeMs *= 1e3;
-    }
-    return new Date(creationTimeMs);
-  }
-  get isRecording() {
-    var _a;
-    return ((_a = this.info) == null ? void 0 : _a.activeRecording) ?? false;
-  }
-  /**
-   * The time in seconds after which a room will be closed after the last
-   * participant has disconnected.
-   */
-  get departureTimeout() {
-    var _a;
-    return ((_a = this.info) == null ? void 0 : _a.departureTimeout) ?? 0;
-  }
-  /**
-   * The time in seconds after which an empty room will be automatically closed.
-   */
-  get emptyTimeout() {
-    var _a;
-    return ((_a = this.info) == null ? void 0 : _a.emptyTimeout) ?? 0;
-  }
-  /**
-   * Connects to a LiveKit room using the provided URL and access token.
-   * @param url - The WebSocket URL of the LiveKit server
-   * @param token - A valid LiveKit access token for authentication
-   * @param opts - Optional room configuration options
-   * @throws ConnectError - if connection fails
-   */
-  async connect(url, token, opts) {
-    const options = { ...defaultRoomOptions, ...opts };
-    const e2eeEnabled = options.encryption || options.e2ee;
-    const e2eeOptions = options.encryption ? { ...defaultE2EEOptions, ...options.encryption } : { ...defaultE2EEOptions, ...options.e2ee };
-    const req = new ConnectRequest({
-      url,
-      token,
-      options
-    });
-    FfiClient.instance.on(FfiClientEvent.FfiEvent, this.onFfiEvent);
-    try {
-      const res = FfiClient.instance.request({
-        message: {
-          case: "connect",
-          value: req
-        }
-      });
-      const cb = await FfiClient.instance.waitFor((ev) => {
-        return ev.message.case == "connect" && ev.message.value.asyncId == res.asyncId;
-      });
-      log.debug("Connect callback received");
-      switch (cb.message.case) {
-        case "result":
-          this.ffiHandle = new FfiHandle(cb.message.value.room.handle.id);
-          this.e2eeManager = e2eeEnabled && new E2EEManager(this.ffiHandle.handle, e2eeOptions);
-          this._token = token;
-          this._serverUrl = url;
-          this.info = cb.message.value.room.info;
-          this.disconnectController = new AbortController();
-          this.hasCleanedUp = false;
-          this.localParticipant = new LocalParticipant(
-            cb.message.value.localParticipant,
-            this.ffiEventLock,
-            this.disconnectController.signal
-          );
-          for (const pt of cb.message.value.participants) {
-            const rp = this.createRemoteParticipant(pt.participant);
-            for (const pub of pt.publications) {
-              const publication = new RemoteTrackPublication(pub);
-              rp.trackPublications.set(publication.sid, publication);
-            }
-          }
-          this.updateConnectionState(ConnectionState.CONN_CONNECTED);
-          FfiClient.instance.request({
-            message: {
-              case: "readyForRoomEvent",
-              value: {
-                roomHandle: this.ffiHandle.handle
-              }
-            }
-          });
-          break;
-        case "error":
-        default:
-          throw new ConnectError(cb.message.value || "");
-      }
-    } catch (e) {
-      FfiClient.instance.off(FfiClientEvent.FfiEvent, this.onFfiEvent);
-      this.preConnectEvents = [];
-      throw e;
-    }
-  }
-  /**
-   * Disconnects from the room and cleans up all resources.
-   * This will stop all tracks and close the connection.
-   */
-  async disconnect() {
-    var _a;
-    if (!this.isConnected) {
-      return;
-    }
-    const res = FfiClient.instance.request({
-      message: {
-        case: "disconnect",
-        value: {
-          roomHandle: (_a = this.ffiHandle) == null ? void 0 : _a.handle
-        }
-      }
-    });
-    await FfiClient.instance.waitFor((ev) => {
-      return ev.message.case == "disconnect" && ev.message.value.asyncId == res.asyncId;
-    });
-    this.cleanupOnDisconnect(DisconnectReason.CLIENT_INITIATED);
-    FfiClient.instance.removeListener(FfiClientEvent.FfiEvent, this.onFfiEvent);
-    this.removeAllListeners();
-  }
-  /**
-   * Trigger a reconnection / chaos scenario for testing. Most useful in
-   * tests to deterministically force a Resume (signal-only reconnect that
-   * preserves the PeerConnection and existing publications) or a full
-   * reconnect (the SDK rebuilds the RtcSession and re-publishes existing
-   * local tracks; `RoomEvent.Reconnected` fires).
-   */
-  async simulateScenario(scenario) {
-    if (!this.isConnected || !this.ffiHandle) {
-      throw new Error("simulateScenario requires a connected room");
-    }
-    const res = FfiClient.instance.request({
-      message: {
-        case: "simulateScenario",
-        value: {
-          roomHandle: this.ffiHandle.handle,
-          scenario
-        }
-      }
-    });
-    const cb = await FfiClient.instance.waitFor(
-      (ev) => ev.message.case === "simulateScenario" && ev.message.value.asyncId === res.asyncId,
-      { signal: this.disconnectController.signal }
-    );
-    if (cb.error) {
-      throw new Error(`simulateScenario failed: ${cb.error}`);
-    }
-  }
-  updateConnectionState(newState) {
-    if (this._connectionState === newState) {
-      return;
-    }
-    this._connectionState = newState;
-    this.emit("connectionStateChanged" /* ConnectionStateChanged */, this._connectionState);
-  }
-  // Runs at most once per connection session. The FFI layer and explicit
-  // disconnect() both race to get here — whichever wins emits the events,
-  // the other is a no-op. A reconnect via connect() clears hasCleanedUp.
-  cleanupOnDisconnect(reason = DisconnectReason.CLIENT_INITIATED) {
-    var _a, _b;
-    if (this.hasCleanedUp) return;
-    this.hasCleanedUp = true;
-    for (const [, streamController] of this.byteStreamControllers) {
-      try {
-        streamController.controller.error(new Error("Disconnected while receiving"));
-      } catch {
-      }
-    }
-    this.byteStreamControllers.clear();
-    for (const [, streamController] of this.textStreamControllers) {
-      try {
-        streamController.controller.error(new Error("Disconnected while receiving"));
-      } catch {
-      }
-    }
-    this.textStreamControllers.clear();
-    if (this.localParticipant) {
-      for (const pub of this.localParticipant.trackPublications.values()) {
-        (_a = pub.track) == null ? void 0 : _a.setRoom(null);
-      }
-    }
-    for (const participant of this.remoteParticipants.values()) {
-      for (const pub of participant.trackPublications.values()) {
-        (_b = pub.track) == null ? void 0 : _b.setRoom(null);
-      }
-    }
-    this.sidPromise = void 0;
-    this.disconnectController.abort();
-    this.updateConnectionState(ConnectionState.CONN_DISCONNECTED);
-    this.emit("disconnected" /* Disconnected */, reason);
-  }
-  /**
-   * Registers a handler for incoming text data streams on a specific topic.
-   * Text streams are used for receiving structured text data from other participants.
-   * @param topic - The topic to listen for text streams on
-   * @param callback - Function to handle incoming text stream data
-   * @throws Error - if a handler for this topic is already registered
-   */
-  registerTextStreamHandler(topic, callback) {
-    if (this.textStreamHandlers.has(topic)) {
-      throw new Error(`A text stream handler for topic "${topic}" has already been set.`);
-    }
-    this.textStreamHandlers.set(topic, callback);
-  }
-  unregisterTextStreamHandler(topic) {
-    this.textStreamHandlers.delete(topic);
-  }
-  /**
-   * Registers a handler for incoming byte data streams on a specific topic.
-   * Byte streams are used for receiving binary data like files from other participants.
-   * @param topic - The topic to listen for byte streams on
-   * @param callback - Function to handle incoming byte stream data
-   * @throws Error - if a handler for this topic is already registered
-   */
-  registerByteStreamHandler(topic, callback) {
-    if (this.byteStreamHandlers.has(topic)) {
-      throw new Error(`A byte stream handler for topic "${topic}" has already been set.`);
-    }
-    this.byteStreamHandlers.set(topic, callback);
-  }
-  unregisterByteStreamHandler(topic) {
-    this.byteStreamHandlers.delete(topic);
-  }
-  retrieveParticipantByIdentity(identity) {
-    var _a;
-    if (((_a = this.localParticipant) == null ? void 0 : _a.identity) === identity) {
-      return this.localParticipant;
-    } else {
-      return this.remoteParticipants.get(identity);
-    }
-  }
-  requireParticipantByIdentity(identity) {
-    var _a;
-    if (((_a = this.localParticipant) == null ? void 0 : _a.identity) === identity) {
-      return this.localParticipant;
-    } else if (this.remoteParticipants.has(identity)) {
-      return this.remoteParticipants.get(identity);
-    } else {
-      throw new TypeError(`participant ${identity} not found`);
-    }
-  }
-  requireRemoteParticipant(identity) {
-    const participant = this.remoteParticipants.get(identity);
-    if (!participant) {
-      throw new TypeError(`participant ${identity} not found`);
-    }
-    return participant;
-  }
-  requirePublicationOfParticipant(identity, trackSid) {
-    const participant = this.requireParticipantByIdentity(identity);
-    const publication = participant.trackPublications.get(trackSid);
-    if (!publication) {
-      throw new TypeError(`publication ${trackSid} not found`);
-    }
-    return { participant, publication };
-  }
-  requirePublicationOfRemoteParticipant(identity, trackSid) {
-    const participant = this.requireRemoteParticipant(identity);
-    const publication = participant.trackPublications.get(trackSid);
-    if (!publication) {
-      throw new TypeError(`publication ${trackSid} not found`);
-    }
-    return { participant, publication };
-  }
-  createRemoteParticipant(ownedInfo) {
-    if (this.remoteParticipants.has(ownedInfo.info.identity)) {
-      throw new Error("Participant already exists");
-    }
-    const participant = new RemoteParticipant(ownedInfo);
-    this.remoteParticipants.set(ownedInfo.info.identity, participant);
-    return participant;
-  }
-  handleStreamHeader(streamHeader, participantIdentity) {
-    if (streamHeader.contentHeader.case === "byteHeader") {
-      const streamHandlerCallback = this.byteStreamHandlers.get(streamHeader.topic ?? "");
-      if (!streamHandlerCallback) {
-        log.debug(
-          "ignoring incoming byte stream due to no handler for topic: %s",
-          streamHeader.topic ?? "undefined"
-        );
-        return;
-      }
-      let streamController;
-      const stream = new ReadableStream({
-        start: (controller) => {
-          streamController = controller;
-          this.byteStreamControllers.set(streamHeader.streamId, {
-            header: streamHeader,
-            controller: streamController,
-            startTime: Date.now()
-          });
-        }
-      });
-      const info = {
-        streamId: streamHeader.streamId,
-        name: streamHeader.contentHeader.value.name ?? "unknown",
-        mimeType: streamHeader.mimeType,
-        totalSize: streamHeader.totalLength ? Number(streamHeader.totalLength) : void 0,
-        topic: streamHeader.topic,
-        timestamp: bigIntToNumber(streamHeader.timestamp),
-        attributes: streamHeader.attributes
-      };
-      streamHandlerCallback(
-        new ByteStreamReader(info, stream, bigIntToNumber(streamHeader.totalLength)),
-        { identity: participantIdentity }
-      );
-    } else if (streamHeader.contentHeader.case === "textHeader") {
-      const streamHandlerCallback = this.textStreamHandlers.get(streamHeader.topic ?? "");
-      if (!streamHandlerCallback) {
-        log.debug(
-          "ignoring incoming text stream due to no handler for topic: %s",
-          streamHeader.topic ?? "undefined"
-        );
-        return;
-      }
-      let streamController;
-      const stream = new ReadableStream({
-        start: (controller) => {
-          streamController = controller;
-          this.textStreamControllers.set(streamHeader.streamId, {
-            header: streamHeader,
-            controller: streamController,
-            startTime: Date.now()
-          });
-        }
-      });
-      const info = {
-        streamId: streamHeader.streamId,
-        mimeType: streamHeader.mimeType,
-        totalSize: streamHeader.totalLength ? Number(streamHeader.totalLength) : void 0,
-        topic: streamHeader.topic,
-        timestamp: Number(streamHeader.timestamp),
-        attributes: streamHeader.attributes
-      };
-      streamHandlerCallback(
-        new TextStreamReader(info, stream, bigIntToNumber(streamHeader.totalLength)),
-        { identity: participantIdentity }
-      );
-    }
-  }
-  handleStreamChunk(chunk) {
-    const fileBuffer = this.byteStreamControllers.get(chunk.streamId);
-    if (fileBuffer) {
-      if (chunk.content.length > 0) {
-        fileBuffer.controller.enqueue(chunk);
-      }
-    }
-    const textBuffer = this.textStreamControllers.get(chunk.streamId);
-    if (textBuffer) {
-      if (chunk.content.length > 0) {
-        textBuffer.controller.enqueue(chunk);
-      }
-    }
-  }
-  handleStreamTrailer(trailer) {
-    const streamId = trailer.streamId;
-    const fileBuffer = this.byteStreamControllers.get(streamId);
-    if (fileBuffer) {
-      fileBuffer.controller.close();
-      this.byteStreamControllers.delete(streamId);
-    }
-    const textBuffer = this.textStreamControllers.get(streamId);
-    if (textBuffer) {
-      textBuffer.controller.close();
-      this.textStreamControllers.delete(streamId);
-    }
-  }
-}
-class ConnectError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-var RoomEvent = /* @__PURE__ */ ((RoomEvent2) => {
-  RoomEvent2["ParticipantConnected"] = "participantConnected";
-  RoomEvent2["ParticipantDisconnected"] = "participantDisconnected";
-  RoomEvent2["LocalTrackPublished"] = "localTrackPublished";
-  RoomEvent2["LocalTrackUnpublished"] = "localTrackUnpublished";
-  RoomEvent2["LocalTrackRepublished"] = "localTrackRepublished";
-  RoomEvent2["LocalTrackSubscribed"] = "localTrackSubscribed";
-  RoomEvent2["TrackPublished"] = "trackPublished";
-  RoomEvent2["TrackUnpublished"] = "trackUnpublished";
-  RoomEvent2["TrackSubscribed"] = "trackSubscribed";
-  RoomEvent2["TrackUnsubscribed"] = "trackUnsubscribed";
-  RoomEvent2["TrackSubscriptionFailed"] = "trackSubscriptionFailed";
-  RoomEvent2["TrackMuted"] = "trackMuted";
-  RoomEvent2["TrackUnmuted"] = "trackUnmuted";
-  RoomEvent2["ActiveSpeakersChanged"] = "activeSpeakersChanged";
-  RoomEvent2["RoomMetadataChanged"] = "roomMetadataChanged";
-  RoomEvent2["RoomSidChanged"] = "roomSidChanged";
-  RoomEvent2["ParticipantMetadataChanged"] = "participantMetadataChanged";
-  RoomEvent2["ParticipantNameChanged"] = "participantNameChanged";
-  RoomEvent2["ParticipantAttributesChanged"] = "participantAttributesChanged";
-  RoomEvent2["ParticipantEncryptionStatusChanged"] = "participantEncryptionStatusChanged";
-  RoomEvent2["ConnectionQualityChanged"] = "connectionQualityChanged";
-  RoomEvent2["DataReceived"] = "dataReceived";
-  RoomEvent2["ChatMessage"] = "chatMessage";
-  RoomEvent2["DtmfReceived"] = "dtmfReceived";
-  RoomEvent2["EncryptionError"] = "encryptionError";
-  RoomEvent2["ConnectionStateChanged"] = "connectionStateChanged";
-  RoomEvent2["Connected"] = "connected";
-  RoomEvent2["Disconnected"] = "disconnected";
-  RoomEvent2["Reconnecting"] = "reconnecting";
-  RoomEvent2["Reconnected"] = "reconnected";
-  RoomEvent2["RoomUpdated"] = "roomUpdated";
-  RoomEvent2["Moved"] = "moved";
-  RoomEvent2["TokenRefreshed"] = "tokenRefreshed";
-  return RoomEvent2;
-})(RoomEvent || {});
-export {
-  ConnectError,
-  Room,
-  RoomEvent,
-  defaultRoomOptions,
-  defaultRtcConfiguration
-};
-//# sourceMappingURL=room.js.map