livekit-client 2.15.7 → 2.15.9

package/dist/livekit-client.esm.mjs

@@ -3780,6 +3780,42 @@ const EventMetric = /* @__PURE__ */proto3.makeMessageType("livekit.EventMetric",
   T: 13
   /* ScalarType.UINT32 */
 }]);
+const AudioCodec = /* @__PURE__ */proto3.makeEnum("livekit.AudioCodec", [{
+  no: 0,
+  name: "DEFAULT_AC"
+}, {
+  no: 1,
+  name: "OPUS"
+}, {
+  no: 2,
+  name: "AAC"
+}, {
+  no: 3,
+  name: "AC_MP3"
+}]);
+const VideoCodec = /* @__PURE__ */proto3.makeEnum("livekit.VideoCodec", [{
+  no: 0,
+  name: "DEFAULT_VC"
+}, {
+  no: 1,
+  name: "H264_BASELINE"
+}, {
+  no: 2,
+  name: "H264_MAIN"
+}, {
+  no: 3,
+  name: "H264_HIGH"
+}, {
+  no: 4,
+  name: "VP8"
+}]);
+const ImageCodec = /* @__PURE__ */proto3.makeEnum("livekit.ImageCodec", [{
+  no: 0,
+  name: "IC_DEFAULT"
+}, {
+  no: 1,
+  name: "IC_JPEG"
+}]);
 const BackupCodecPolicy$1 = /* @__PURE__ */proto3.makeEnum("livekit.BackupCodecPolicy", [{
   no: 0,
   name: "PREFER_REGRESSION"
@@ -4268,6 +4304,17 @@ const SimulcastCodecInfo = /* @__PURE__ */proto3.makeMessageType("livekit.Simulc
   kind: "message",
   T: VideoLayer,
   repeated: true
+}, {
+  no: 5,
+  name: "video_layer_mode",
+  kind: "enum",
+  T: proto3.getEnumType(VideoLayer_Mode)
+}, {
+  no: 6,
+  name: "sdp_cid",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
 }]);
 const TrackInfo = /* @__PURE__ */proto3.makeMessageType("livekit.TrackInfo", () => [{
   no: 1,
@@ -4427,6 +4474,19 @@ const VideoLayer = /* @__PURE__ */proto3.makeMessageType("livekit.VideoLayer", (
   T: 9
   /* ScalarType.STRING */
 }]);
+const VideoLayer_Mode = /* @__PURE__ */proto3.makeEnum("livekit.VideoLayer.Mode", [{
+  no: 0,
+  name: "MODE_UNUSED"
+}, {
+  no: 1,
+  name: "ONE_SPATIAL_LAYER_PER_STREAM"
+}, {
+  no: 2,
+  name: "MULTIPLE_SPATIAL_LAYERS_PER_STREAM"
+}, {
+  no: 3,
+  name: "ONE_SPATIAL_LAYER_PER_STREAM_INCOMPLETE_RTCP_SR"
+}]);
 const DataPacket = /* @__PURE__ */proto3.makeMessageType("livekit.DataPacket", () => [{
   no: 1,
   name: "kind",
@@ -4516,6 +4576,12 @@ const DataPacket = /* @__PURE__ */proto3.makeMessageType("livekit.DataPacket", (
   kind: "message",
   T: DataStream_Trailer,
   oneof: "value"
+}, {
+  no: 18,
+  name: "encrypted_packet",
+  kind: "message",
+  T: EncryptedPacket,
+  oneof: "value"
 }, {
   no: 16,
   name: "sequence",
@@ -4536,6 +4602,79 @@ const DataPacket_Kind = /* @__PURE__ */proto3.makeEnum("livekit.DataPacket.Kind"
   no: 1,
   name: "LOSSY"
 }]);
+const EncryptedPacket = /* @__PURE__ */proto3.makeMessageType("livekit.EncryptedPacket", () => [{
+  no: 1,
+  name: "encryption_type",
+  kind: "enum",
+  T: proto3.getEnumType(Encryption_Type)
+}, {
+  no: 2,
+  name: "iv",
+  kind: "scalar",
+  T: 12
+  /* ScalarType.BYTES */
+}, {
+  no: 3,
+  name: "key_index",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 4,
+  name: "encrypted_value",
+  kind: "scalar",
+  T: 12
+  /* ScalarType.BYTES */
+}]);
+const EncryptedPacketPayload = /* @__PURE__ */proto3.makeMessageType("livekit.EncryptedPacketPayload", () => [{
+  no: 1,
+  name: "user",
+  kind: "message",
+  T: UserPacket,
+  oneof: "value"
+}, {
+  no: 3,
+  name: "chat_message",
+  kind: "message",
+  T: ChatMessage,
+  oneof: "value"
+}, {
+  no: 4,
+  name: "rpc_request",
+  kind: "message",
+  T: RpcRequest,
+  oneof: "value"
+}, {
+  no: 5,
+  name: "rpc_ack",
+  kind: "message",
+  T: RpcAck,
+  oneof: "value"
+}, {
+  no: 6,
+  name: "rpc_response",
+  kind: "message",
+  T: RpcResponse,
+  oneof: "value"
+}, {
+  no: 7,
+  name: "stream_header",
+  kind: "message",
+  T: DataStream_Header,
+  oneof: "value"
+}, {
+  no: 8,
+  name: "stream_chunk",
+  kind: "message",
+  T: DataStream_Chunk,
+  oneof: "value"
+}, {
+  no: 9,
+  name: "stream_trailer",
+  kind: "message",
+  T: DataStream_Trailer,
+  oneof: "value"
+}]);
 const ActiveSpeakerUpdate = /* @__PURE__ */proto3.makeMessageType("livekit.ActiveSpeakerUpdate", () => [{
   no: 1,
   name: "speakers",
@@ -5209,93 +5348,872 @@ const DataStream_Trailer = /* @__PURE__ */proto3.makeMessageType("livekit.DataSt
 }], {
   localName: "DataStream_Trailer"
 });
-const SignalTarget = /* @__PURE__ */proto3.makeEnum("livekit.SignalTarget", [{
+const WebhookConfig = /* @__PURE__ */proto3.makeMessageType("livekit.WebhookConfig", () => [{
+  no: 1,
+  name: "url",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "signing_key",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}]);
+const SubscribedAudioCodec = /* @__PURE__ */proto3.makeMessageType("livekit.SubscribedAudioCodec", () => [{
+  no: 1,
+  name: "codec",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "enabled",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}]);
+const RoomAgentDispatch = /* @__PURE__ */proto3.makeMessageType("livekit.RoomAgentDispatch", () => [{
+  no: 1,
+  name: "agent_name",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "metadata",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}]);
+const EncodedFileType = /* @__PURE__ */proto3.makeEnum("livekit.EncodedFileType", [{
   no: 0,
-  name: "PUBLISHER"
+  name: "DEFAULT_FILETYPE"
 }, {
   no: 1,
-  name: "SUBSCRIBER"
+  name: "MP4"
+}, {
+  no: 2,
+  name: "OGG"
+}, {
+  no: 3,
+  name: "MP3"
 }]);
-const StreamState = /* @__PURE__ */proto3.makeEnum("livekit.StreamState", [{
+const SegmentedFileProtocol = /* @__PURE__ */proto3.makeEnum("livekit.SegmentedFileProtocol", [{
   no: 0,
-  name: "ACTIVE"
+  name: "DEFAULT_SEGMENTED_FILE_PROTOCOL"
 }, {
   no: 1,
-  name: "PAUSED"
+  name: "HLS_PROTOCOL"
 }]);
-const CandidateProtocol = /* @__PURE__ */proto3.makeEnum("livekit.CandidateProtocol", [{
+const SegmentedFileSuffix = /* @__PURE__ */proto3.makeEnum("livekit.SegmentedFileSuffix", [{
   no: 0,
-  name: "UDP"
+  name: "INDEX"
 }, {
   no: 1,
-  name: "TCP"
+  name: "TIMESTAMP"
+}]);
+const ImageFileSuffix = /* @__PURE__ */proto3.makeEnum("livekit.ImageFileSuffix", [{
+  no: 0,
+  name: "IMAGE_SUFFIX_INDEX"
+}, {
+  no: 1,
+  name: "IMAGE_SUFFIX_TIMESTAMP"
 }, {
   no: 2,
-  name: "TLS"
+  name: "IMAGE_SUFFIX_NONE_OVERWRITE"
 }]);
-const SignalRequest = /* @__PURE__ */proto3.makeMessageType("livekit.SignalRequest", () => [{
+const StreamProtocol = /* @__PURE__ */proto3.makeEnum("livekit.StreamProtocol", [{
+  no: 0,
+  name: "DEFAULT_PROTOCOL"
+}, {
   no: 1,
-  name: "offer",
-  kind: "message",
-  T: SessionDescription,
-  oneof: "message"
+  name: "RTMP"
 }, {
   no: 2,
-  name: "answer",
-  kind: "message",
-  T: SessionDescription,
-  oneof: "message"
+  name: "SRT"
+}]);
+const AudioMixing = /* @__PURE__ */proto3.makeEnum("livekit.AudioMixing", [{
+  no: 0,
+  name: "DEFAULT_MIXING"
+}, {
+  no: 1,
+  name: "DUAL_CHANNEL_AGENT"
+}, {
+  no: 2,
+  name: "DUAL_CHANNEL_ALTERNATE"
+}]);
+const EncodingOptionsPreset = /* @__PURE__ */proto3.makeEnum("livekit.EncodingOptionsPreset", [{
+  no: 0,
+  name: "H264_720P_30"
+}, {
+  no: 1,
+  name: "H264_720P_60"
+}, {
+  no: 2,
+  name: "H264_1080P_30"
 }, {
   no: 3,
-  name: "trickle",
-  kind: "message",
-  T: TrickleRequest,
-  oneof: "message"
+  name: "H264_1080P_60"
 }, {
   no: 4,
-  name: "add_track",
-  kind: "message",
-  T: AddTrackRequest,
-  oneof: "message"
+  name: "PORTRAIT_H264_720P_30"
 }, {
   no: 5,
-  name: "mute",
-  kind: "message",
-  T: MuteTrackRequest,
-  oneof: "message"
+  name: "PORTRAIT_H264_720P_60"
 }, {
   no: 6,
-  name: "subscription",
-  kind: "message",
-  T: UpdateSubscription,
-  oneof: "message"
+  name: "PORTRAIT_H264_1080P_30"
 }, {
   no: 7,
-  name: "track_setting",
+  name: "PORTRAIT_H264_1080P_60"
+}]);
+const RoomCompositeEgressRequest = /* @__PURE__ */proto3.makeMessageType("livekit.RoomCompositeEgressRequest", () => [{
+  no: 1,
+  name: "room_name",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "layout",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 3,
+  name: "audio_only",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 15,
+  name: "audio_mixing",
+  kind: "enum",
+  T: proto3.getEnumType(AudioMixing)
+}, {
+  no: 4,
+  name: "video_only",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 5,
+  name: "custom_base_url",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 6,
+  name: "file",
   kind: "message",
-  T: UpdateTrackSettings,
-  oneof: "message"
+  T: EncodedFileOutput,
+  oneof: "output"
 }, {
-  no: 8,
-  name: "leave",
+  no: 7,
+  name: "stream",
   kind: "message",
-  T: LeaveRequest,
-  oneof: "message"
+  T: StreamOutput,
+  oneof: "output"
 }, {
   no: 10,
-  name: "update_layers",
+  name: "segments",
   kind: "message",
-  T: UpdateVideoLayers,
-  oneof: "message"
+  T: SegmentedFileOutput,
+  oneof: "output"
+}, {
+  no: 8,
+  name: "preset",
+  kind: "enum",
+  T: proto3.getEnumType(EncodingOptionsPreset),
+  oneof: "options"
+}, {
+  no: 9,
+  name: "advanced",
+  kind: "message",
+  T: EncodingOptions,
+  oneof: "options"
 }, {
   no: 11,
-  name: "subscription_permission",
+  name: "file_outputs",
   kind: "message",
-  T: SubscriptionPermission,
-  oneof: "message"
+  T: EncodedFileOutput,
+  repeated: true
 }, {
   no: 12,
-  name: "sync_state",
+  name: "stream_outputs",
+  kind: "message",
+  T: StreamOutput,
+  repeated: true
+}, {
+  no: 13,
+  name: "segment_outputs",
+  kind: "message",
+  T: SegmentedFileOutput,
+  repeated: true
+}, {
+  no: 14,
+  name: "image_outputs",
+  kind: "message",
+  T: ImageOutput,
+  repeated: true
+}, {
+  no: 16,
+  name: "webhooks",
+  kind: "message",
+  T: WebhookConfig,
+  repeated: true
+}]);
+const EncodedFileOutput = /* @__PURE__ */proto3.makeMessageType("livekit.EncodedFileOutput", () => [{
+  no: 1,
+  name: "file_type",
+  kind: "enum",
+  T: proto3.getEnumType(EncodedFileType)
+}, {
+  no: 2,
+  name: "filepath",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 6,
+  name: "disable_manifest",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 3,
+  name: "s3",
+  kind: "message",
+  T: S3Upload,
+  oneof: "output"
+}, {
+  no: 4,
+  name: "gcp",
+  kind: "message",
+  T: GCPUpload,
+  oneof: "output"
+}, {
+  no: 5,
+  name: "azure",
+  kind: "message",
+  T: AzureBlobUpload,
+  oneof: "output"
+}, {
+  no: 7,
+  name: "aliOSS",
+  kind: "message",
+  T: AliOSSUpload,
+  oneof: "output"
+}]);
+const SegmentedFileOutput = /* @__PURE__ */proto3.makeMessageType("livekit.SegmentedFileOutput", () => [{
+  no: 1,
+  name: "protocol",
+  kind: "enum",
+  T: proto3.getEnumType(SegmentedFileProtocol)
+}, {
+  no: 2,
+  name: "filename_prefix",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 3,
+  name: "playlist_name",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 11,
+  name: "live_playlist_name",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 4,
+  name: "segment_duration",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 10,
+  name: "filename_suffix",
+  kind: "enum",
+  T: proto3.getEnumType(SegmentedFileSuffix)
+}, {
+  no: 8,
+  name: "disable_manifest",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 5,
+  name: "s3",
+  kind: "message",
+  T: S3Upload,
+  oneof: "output"
+}, {
+  no: 6,
+  name: "gcp",
+  kind: "message",
+  T: GCPUpload,
+  oneof: "output"
+}, {
+  no: 7,
+  name: "azure",
+  kind: "message",
+  T: AzureBlobUpload,
+  oneof: "output"
+}, {
+  no: 9,
+  name: "aliOSS",
+  kind: "message",
+  T: AliOSSUpload,
+  oneof: "output"
+}]);
+const ImageOutput = /* @__PURE__ */proto3.makeMessageType("livekit.ImageOutput", () => [{
+  no: 1,
+  name: "capture_interval",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 2,
+  name: "width",
+  kind: "scalar",
+  T: 5
+  /* ScalarType.INT32 */
+}, {
+  no: 3,
+  name: "height",
+  kind: "scalar",
+  T: 5
+  /* ScalarType.INT32 */
+}, {
+  no: 4,
+  name: "filename_prefix",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 5,
+  name: "filename_suffix",
+  kind: "enum",
+  T: proto3.getEnumType(ImageFileSuffix)
+}, {
+  no: 6,
+  name: "image_codec",
+  kind: "enum",
+  T: proto3.getEnumType(ImageCodec)
+}, {
+  no: 7,
+  name: "disable_manifest",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 8,
+  name: "s3",
+  kind: "message",
+  T: S3Upload,
+  oneof: "output"
+}, {
+  no: 9,
+  name: "gcp",
+  kind: "message",
+  T: GCPUpload,
+  oneof: "output"
+}, {
+  no: 10,
+  name: "azure",
+  kind: "message",
+  T: AzureBlobUpload,
+  oneof: "output"
+}, {
+  no: 11,
+  name: "aliOSS",
+  kind: "message",
+  T: AliOSSUpload,
+  oneof: "output"
+}]);
+const S3Upload = /* @__PURE__ */proto3.makeMessageType("livekit.S3Upload", () => [{
+  no: 1,
+  name: "access_key",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "secret",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 11,
+  name: "session_token",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 12,
+  name: "assume_role_arn",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 13,
+  name: "assume_role_external_id",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 3,
+  name: "region",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 4,
+  name: "endpoint",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 5,
+  name: "bucket",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 6,
+  name: "force_path_style",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 7,
+  name: "metadata",
+  kind: "map",
+  K: 9,
+  V: {
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  }
+}, {
+  no: 8,
+  name: "tagging",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 9,
+  name: "content_disposition",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 10,
+  name: "proxy",
+  kind: "message",
+  T: ProxyConfig
+}]);
+const GCPUpload = /* @__PURE__ */proto3.makeMessageType("livekit.GCPUpload", () => [{
+  no: 1,
+  name: "credentials",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "bucket",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 3,
+  name: "proxy",
+  kind: "message",
+  T: ProxyConfig
+}]);
+const AzureBlobUpload = /* @__PURE__ */proto3.makeMessageType("livekit.AzureBlobUpload", () => [{
+  no: 1,
+  name: "account_name",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "account_key",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 3,
+  name: "container_name",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}]);
+const AliOSSUpload = /* @__PURE__ */proto3.makeMessageType("livekit.AliOSSUpload", () => [{
+  no: 1,
+  name: "access_key",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "secret",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 3,
+  name: "region",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 4,
+  name: "endpoint",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 5,
+  name: "bucket",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}]);
+const ProxyConfig = /* @__PURE__ */proto3.makeMessageType("livekit.ProxyConfig", () => [{
+  no: 1,
+  name: "url",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "username",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 3,
+  name: "password",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}]);
+const StreamOutput = /* @__PURE__ */proto3.makeMessageType("livekit.StreamOutput", () => [{
+  no: 1,
+  name: "protocol",
+  kind: "enum",
+  T: proto3.getEnumType(StreamProtocol)
+}, {
+  no: 2,
+  name: "urls",
+  kind: "scalar",
+  T: 9,
+  repeated: true
+}]);
+const EncodingOptions = /* @__PURE__ */proto3.makeMessageType("livekit.EncodingOptions", () => [{
+  no: 1,
+  name: "width",
+  kind: "scalar",
+  T: 5
+  /* ScalarType.INT32 */
+}, {
+  no: 2,
+  name: "height",
+  kind: "scalar",
+  T: 5
+  /* ScalarType.INT32 */
+}, {
+  no: 3,
+  name: "depth",
+  kind: "scalar",
+  T: 5
+  /* ScalarType.INT32 */
+}, {
+  no: 4,
+  name: "framerate",
+  kind: "scalar",
+  T: 5
+  /* ScalarType.INT32 */
+}, {
+  no: 5,
+  name: "audio_codec",
+  kind: "enum",
+  T: proto3.getEnumType(AudioCodec)
+}, {
+  no: 6,
+  name: "audio_bitrate",
+  kind: "scalar",
+  T: 5
+  /* ScalarType.INT32 */
+}, {
+  no: 11,
+  name: "audio_quality",
+  kind: "scalar",
+  T: 5
+  /* ScalarType.INT32 */
+}, {
+  no: 7,
+  name: "audio_frequency",
+  kind: "scalar",
+  T: 5
+  /* ScalarType.INT32 */
+}, {
+  no: 8,
+  name: "video_codec",
+  kind: "enum",
+  T: proto3.getEnumType(VideoCodec)
+}, {
+  no: 9,
+  name: "video_bitrate",
+  kind: "scalar",
+  T: 5
+  /* ScalarType.INT32 */
+}, {
+  no: 12,
+  name: "video_quality",
+  kind: "scalar",
+  T: 5
+  /* ScalarType.INT32 */
+}, {
+  no: 10,
+  name: "key_frame_interval",
+  kind: "scalar",
+  T: 1
+  /* ScalarType.DOUBLE */
+}]);
+const AutoParticipantEgress = /* @__PURE__ */proto3.makeMessageType("livekit.AutoParticipantEgress", () => [{
+  no: 1,
+  name: "preset",
+  kind: "enum",
+  T: proto3.getEnumType(EncodingOptionsPreset),
+  oneof: "options"
+}, {
+  no: 2,
+  name: "advanced",
+  kind: "message",
+  T: EncodingOptions,
+  oneof: "options"
+}, {
+  no: 3,
+  name: "file_outputs",
+  kind: "message",
+  T: EncodedFileOutput,
+  repeated: true
+}, {
+  no: 4,
+  name: "segment_outputs",
+  kind: "message",
+  T: SegmentedFileOutput,
+  repeated: true
+}]);
+const AutoTrackEgress = /* @__PURE__ */proto3.makeMessageType("livekit.AutoTrackEgress", () => [{
+  no: 1,
+  name: "filepath",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 5,
+  name: "disable_manifest",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 2,
+  name: "s3",
+  kind: "message",
+  T: S3Upload,
+  oneof: "output"
+}, {
+  no: 3,
+  name: "gcp",
+  kind: "message",
+  T: GCPUpload,
+  oneof: "output"
+}, {
+  no: 4,
+  name: "azure",
+  kind: "message",
+  T: AzureBlobUpload,
+  oneof: "output"
+}, {
+  no: 6,
+  name: "aliOSS",
+  kind: "message",
+  T: AliOSSUpload,
+  oneof: "output"
+}]);
+const RoomEgress = /* @__PURE__ */proto3.makeMessageType("livekit.RoomEgress", () => [{
+  no: 1,
+  name: "room",
+  kind: "message",
+  T: RoomCompositeEgressRequest
+}, {
+  no: 3,
+  name: "participant",
+  kind: "message",
+  T: AutoParticipantEgress
+}, {
+  no: 2,
+  name: "tracks",
+  kind: "message",
+  T: AutoTrackEgress
+}]);
+const RoomConfiguration = /* @__PURE__ */proto3.makeMessageType("livekit.RoomConfiguration", () => [{
+  no: 1,
+  name: "name",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "empty_timeout",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 3,
+  name: "departure_timeout",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 4,
+  name: "max_participants",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 11,
+  name: "metadata",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 5,
+  name: "egress",
+  kind: "message",
+  T: RoomEgress
+}, {
+  no: 7,
+  name: "min_playout_delay",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 8,
+  name: "max_playout_delay",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 9,
+  name: "sync_streams",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 10,
+  name: "agents",
+  kind: "message",
+  T: RoomAgentDispatch,
+  repeated: true
+}]);
+const SignalTarget = /* @__PURE__ */proto3.makeEnum("livekit.SignalTarget", [{
+  no: 0,
+  name: "PUBLISHER"
+}, {
+  no: 1,
+  name: "SUBSCRIBER"
+}]);
+const StreamState = /* @__PURE__ */proto3.makeEnum("livekit.StreamState", [{
+  no: 0,
+  name: "ACTIVE"
+}, {
+  no: 1,
+  name: "PAUSED"
+}]);
+const CandidateProtocol = /* @__PURE__ */proto3.makeEnum("livekit.CandidateProtocol", [{
+  no: 0,
+  name: "UDP"
+}, {
+  no: 1,
+  name: "TCP"
+}, {
+  no: 2,
+  name: "TLS"
+}]);
+const SignalRequest = /* @__PURE__ */proto3.makeMessageType("livekit.SignalRequest", () => [{
+  no: 1,
+  name: "offer",
+  kind: "message",
+  T: SessionDescription,
+  oneof: "message"
+}, {
+  no: 2,
+  name: "answer",
+  kind: "message",
+  T: SessionDescription,
+  oneof: "message"
+}, {
+  no: 3,
+  name: "trickle",
+  kind: "message",
+  T: TrickleRequest,
+  oneof: "message"
+}, {
+  no: 4,
+  name: "add_track",
+  kind: "message",
+  T: AddTrackRequest,
+  oneof: "message"
+}, {
+  no: 5,
+  name: "mute",
+  kind: "message",
+  T: MuteTrackRequest,
+  oneof: "message"
+}, {
+  no: 6,
+  name: "subscription",
+  kind: "message",
+  T: UpdateSubscription,
+  oneof: "message"
+}, {
+  no: 7,
+  name: "track_setting",
+  kind: "message",
+  T: UpdateTrackSettings,
+  oneof: "message"
+}, {
+  no: 8,
+  name: "leave",
+  kind: "message",
+  T: LeaveRequest,
+  oneof: "message"
+}, {
+  no: 10,
+  name: "update_layers",
+  kind: "message",
+  T: UpdateVideoLayers,
+  oneof: "message"
+}, {
+  no: 11,
+  name: "subscription_permission",
+  kind: "message",
+  T: SubscriptionPermission,
+  oneof: "message"
+}, {
+  no: 12,
+  name: "sync_state",
   kind: "message",
   T: SyncState,
   oneof: "message"
@@ -5474,6 +6392,18 @@ const SignalResponse = /* @__PURE__ */proto3.makeMessageType("livekit.SignalResp
   kind: "message",
   T: RoomMovedResponse,
   oneof: "message"
+}, {
+  no: 25,
+  name: "media_sections_requirement",
+  kind: "message",
+  T: MediaSectionsRequirement,
+  oneof: "message"
+}, {
+  no: 26,
+  name: "subscribed_audio_codec_update",
+  kind: "message",
+  T: SubscribedAudioCodecUpdate,
+  oneof: "message"
 }]);
 const SimulcastCodec = /* @__PURE__ */proto3.makeMessageType("livekit.SimulcastCodec", () => [{
   no: 1,
@@ -5487,6 +6417,17 @@ const SimulcastCodec = /* @__PURE__ */proto3.makeMessageType("livekit.SimulcastC
   kind: "scalar",
   T: 9
   /* ScalarType.STRING */
+}, {
+  no: 4,
+  name: "layers",
+  kind: "message",
+  T: VideoLayer,
+  repeated: true
+}, {
+  no: 5,
+  name: "video_layer_mode",
+  kind: "enum",
+  T: proto3.getEnumType(VideoLayer_Mode)
 }]);
 const AddTrackRequest = /* @__PURE__ */proto3.makeMessageType("livekit.AddTrackRequest", () => [{
   no: 1,
@@ -6066,6 +7007,19 @@ const SubscribedQualityUpdate = /* @__PURE__ */proto3.makeMessageType("livekit.S
   T: SubscribedCodec,
   repeated: true
 }]);
+const SubscribedAudioCodecUpdate = /* @__PURE__ */proto3.makeMessageType("livekit.SubscribedAudioCodecUpdate", () => [{
+  no: 1,
+  name: "track_sid",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "subscribed_audio_codecs",
+  kind: "message",
+  T: SubscribedAudioCodec,
+  repeated: true
+}]);
 const TrackPermission = /* @__PURE__ */proto3.makeMessageType("livekit.TrackPermission", () => [{
   no: 1,
   name: "participant_sid",
@@ -6338,38 +7292,254 @@ const SubscriptionResponse = /* @__PURE__ */proto3.makeMessageType("livekit.Subs
 }]);
 const RequestResponse = /* @__PURE__ */proto3.makeMessageType("livekit.RequestResponse", () => [{
   no: 1,
-  name: "request_id",
+  name: "request_id",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 2,
+  name: "reason",
+  kind: "enum",
+  T: proto3.getEnumType(RequestResponse_Reason)
+}, {
+  no: 3,
+  name: "message",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 4,
+  name: "trickle",
+  kind: "message",
+  T: TrickleRequest,
+  oneof: "request"
+}, {
+  no: 5,
+  name: "add_track",
+  kind: "message",
+  T: AddTrackRequest,
+  oneof: "request"
+}, {
+  no: 6,
+  name: "mute",
+  kind: "message",
+  T: MuteTrackRequest,
+  oneof: "request"
+}, {
+  no: 7,
+  name: "update_metadata",
+  kind: "message",
+  T: UpdateParticipantMetadata,
+  oneof: "request"
+}, {
+  no: 8,
+  name: "update_audio_track",
+  kind: "message",
+  T: UpdateLocalAudioTrack,
+  oneof: "request"
+}, {
+  no: 9,
+  name: "update_video_track",
+  kind: "message",
+  T: UpdateLocalVideoTrack,
+  oneof: "request"
+}]);
+const RequestResponse_Reason = /* @__PURE__ */proto3.makeEnum("livekit.RequestResponse.Reason", [{
+  no: 0,
+  name: "OK"
+}, {
+  no: 1,
+  name: "NOT_FOUND"
+}, {
+  no: 2,
+  name: "NOT_ALLOWED"
+}, {
+  no: 3,
+  name: "LIMIT_EXCEEDED"
+}, {
+  no: 4,
+  name: "QUEUED"
+}, {
+  no: 5,
+  name: "UNSUPPORTED_TYPE"
+}, {
+  no: 6,
+  name: "UNCLASSIFIED_ERROR"
+}]);
+const TrackSubscribed = /* @__PURE__ */proto3.makeMessageType("livekit.TrackSubscribed", () => [{
+  no: 1,
+  name: "track_sid",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}]);
+const ConnectionSettings = /* @__PURE__ */proto3.makeMessageType("livekit.ConnectionSettings", () => [{
+  no: 1,
+  name: "auto_subscribe",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 2,
+  name: "adaptive_stream",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 3,
+  name: "subscriber_allow_pause",
+  kind: "scalar",
+  T: 8,
+  opt: true
+}, {
+  no: 4,
+  name: "disable_ice_lite",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}]);
+const JoinRequest = /* @__PURE__ */proto3.makeMessageType("livekit.JoinRequest", () => [{
+  no: 1,
+  name: "client_info",
+  kind: "message",
+  T: ClientInfo
+}, {
+  no: 2,
+  name: "connection_settings",
+  kind: "message",
+  T: ConnectionSettings
+}, {
+  no: 3,
+  name: "metadata",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 4,
+  name: "participant_attributes",
+  kind: "map",
+  K: 9,
+  V: {
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  }
+}, {
+  no: 5,
+  name: "add_track_requests",
+  kind: "message",
+  T: AddTrackRequest,
+  repeated: true
+}, {
+  no: 6,
+  name: "publisher_offer",
+  kind: "message",
+  T: SessionDescription
+}, {
+  no: 7,
+  name: "reconnect",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 8,
+  name: "reconnect_reason",
+  kind: "enum",
+  T: proto3.getEnumType(ReconnectReason)
+}, {
+  no: 9,
+  name: "participant_sid",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 10,
+  name: "sync_state",
+  kind: "message",
+  T: SyncState
+}]);
+const WrappedJoinRequest = /* @__PURE__ */proto3.makeMessageType("livekit.WrappedJoinRequest", () => [{
+  no: 1,
+  name: "compression",
+  kind: "enum",
+  T: proto3.getEnumType(WrappedJoinRequest_Compression)
+}, {
+  no: 2,
+  name: "join_request",
+  kind: "scalar",
+  T: 12
+  /* ScalarType.BYTES */
+}]);
+const WrappedJoinRequest_Compression = /* @__PURE__ */proto3.makeEnum("livekit.WrappedJoinRequest.Compression", [{
+  no: 0,
+  name: "NONE"
+}, {
+  no: 1,
+  name: "GZIP"
+}]);
+const MediaSectionsRequirement = /* @__PURE__ */proto3.makeMessageType("livekit.MediaSectionsRequirement", () => [{
+  no: 1,
+  name: "num_audios",
   kind: "scalar",
   T: 13
   /* ScalarType.UINT32 */
 }, {
   no: 2,
-  name: "reason",
-  kind: "enum",
-  T: proto3.getEnumType(RequestResponse_Reason)
-}, {
-  no: 3,
-  name: "message",
+  name: "num_videos",
   kind: "scalar",
-  T: 9
-  /* ScalarType.STRING */
+  T: 13
+  /* ScalarType.UINT32 */
 }]);
-const RequestResponse_Reason = /* @__PURE__ */proto3.makeEnum("livekit.RequestResponse.Reason", [{
-  no: 0,
-  name: "OK"
-}, {
+const TokenSourceRequest = /* @__PURE__ */proto3.makeMessageType("livekit.TokenSourceRequest", () => [{
   no: 1,
-  name: "NOT_FOUND"
+  name: "room_name",
+  kind: "scalar",
+  T: 9,
+  opt: true
 }, {
   no: 2,
-  name: "NOT_ALLOWED"
+  name: "participant_name",
+  kind: "scalar",
+  T: 9,
+  opt: true
 }, {
   no: 3,
-  name: "LIMIT_EXCEEDED"
+  name: "participant_identity",
+  kind: "scalar",
+  T: 9,
+  opt: true
+}, {
+  no: 4,
+  name: "participant_metadata",
+  kind: "scalar",
+  T: 9,
+  opt: true
+}, {
+  no: 5,
+  name: "participant_attributes",
+  kind: "map",
+  K: 9,
+  V: {
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  }
+}, {
+  no: 6,
+  name: "room_config",
+  kind: "message",
+  T: RoomConfiguration,
+  opt: true
 }]);
-const TrackSubscribed = /* @__PURE__ */proto3.makeMessageType("livekit.TrackSubscribed", () => [{
+const TokenSourceResponse = /* @__PURE__ */proto3.makeMessageType("livekit.TokenSourceResponse", () => [{
   no: 1,
-  name: "track_sid",
+  name: "server_url",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "participant_token",
   kind: "scalar",
   T: 9
   /* ScalarType.STRING */
@@ -6718,6 +7888,7 @@ var LoggerNames;
 (function (LoggerNames) {
   LoggerNames["Default"] = "livekit";
   LoggerNames["Room"] = "livekit-room";
+  LoggerNames["TokenSource"] = "livekit-token-source";
   LoggerNames["Participant"] = "livekit-participant";
   LoggerNames["Track"] = "livekit-track";
   LoggerNames["Publication"] = "livekit-track-publication";
@@ -7432,7 +8603,7 @@ function detectBrowser(window) {
  * @param {*} val The something you want to check.
  * @return true if val is an object, false otherwise.
  */
-function isObject(val) {
+function isObject$1(val) {
   return Object.prototype.toString.call(val) === '[object Object]';
 }
 
@@ -7442,11 +8613,11 @@ function isObject(val) {
  * of Lodash's `compact`.
  */
 function compactObject(data) {
-  if (!isObject(data)) {
+  if (!isObject$1(data)) {
     return data;
   }
   return Object.keys(data).reduce(function (accumulator, key) {
-    const isObj = isObject(data[key]);
+    const isObj = isObject$1(data[key]);
     const value = isObj ? compactObject(data[key]) : data[key];
     const isEmptyObject = isObj && !Object.keys(value).length;
     if (value === undefined || isEmptyObject) {
@@ -10453,6 +11624,15 @@ function writeRbsp(data_in) {
   }
   return new Uint8Array(dataOut);
 }
+function asEncryptablePacket(packet) {
+  var _a, _b, _c, _d, _e;
+  if (((_a = packet.value) === null || _a === void 0 ? void 0 : _a.case) !== 'sipDtmf' && ((_b = packet.value) === null || _b === void 0 ? void 0 : _b.case) !== 'metrics' && ((_c = packet.value) === null || _c === void 0 ? void 0 : _c.case) !== 'speaker' && ((_d = packet.value) === null || _d === void 0 ? void 0 : _d.case) !== 'transcription' && ((_e = packet.value) === null || _e === void 0 ? void 0 : _e.case) !== 'encryptedPacket') {
+    return new EncryptedPacketPayload({
+      value: packet.value
+    });
+  }
+  return undefined;
+}
 
 /**
  * @experimental
@@ -10632,6 +11812,8 @@ var DataStreamErrorReason;
   DataStreamErrorReason[DataStreamErrorReason["Incomplete"] = 4] = "Incomplete";
   // Unable to register a stream handler more than once.
   DataStreamErrorReason[DataStreamErrorReason["HandlerAlreadyRegistered"] = 7] = "HandlerAlreadyRegistered";
+  // Encryption type mismatch.
+  DataStreamErrorReason[DataStreamErrorReason["EncryptionTypeMismatch"] = 8] = "EncryptionTypeMismatch";
 })(DataStreamErrorReason || (DataStreamErrorReason = {}));
 class DataStreamError extends LivekitError {
   constructor(message, reason) {
@@ -11388,7 +12570,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.15.7";
+var version$1 = "2.15.9";
 
 const version = version$1;
 const protocolVersion = 16;
@@ -11828,11 +13010,15 @@ class VideoPreset {
     };
   }
 }
-const backupCodecs = ['vp8', 'h264'];
+// `red` is not technically a codec, but treated as one in signalling protocol
+const audioCodecs = ['opus', 'red'];
+const backupVideoCodecs = ['vp8', 'h264'];
 const videoCodecs = ['vp8', 'h264', 'vp9', 'av1', 'h265'];
-function isBackupCodec(codec) {
-  return !!backupCodecs.find(backup => backup === codec);
+function isBackupVideoCodec(codec) {
+  return !!backupVideoCodecs.find(backup => backup === codec);
 }
+/** @deprecated Use {@link isBackupVideoCodec} instead */
+const isBackupCodec = isBackupVideoCodec;
 var BackupCodecPolicy;
 (function (BackupCodecPolicy) {
   // codec regression is preferred, the sfu will try to regress codec if possible but not guaranteed
@@ -11944,7 +13130,7 @@ function supportsAV1() {
   let hasAV1 = false;
   if (capabilities) {
     for (const codec of capabilities.codecs) {
-      if (codec.mimeType === 'video/AV1') {
+      if (codec.mimeType.toLowerCase() === 'video/av1') {
         hasAV1 = true;
         break;
       }
@@ -11976,7 +13162,7 @@ function supportsVP9() {
   let hasVP9 = false;
   if (capabilities) {
     for (const codec of capabilities.codecs) {
-      if (codec.mimeType === 'video/VP9') {
+      if (codec.mimeType.toLowerCase() === 'video/vp9') {
         hasVP9 = true;
         break;
       }
@@ -11996,6 +13182,14 @@ function supportsSetSinkId(elm) {
   }
   return 'setSinkId' in elm;
 }
+/**
+ * Checks whether or not setting an audio output via {@link Room#setActiveDevice}
+ * is supported for the current browser.
+ */
+function supportsAudioOutputSelection() {
+  // Note: this is method publicly exported under a user friendly name and currently only proxying `supportsSetSinkId`
+  return supportsSetSinkId();
+}
 function isBrowserSupported() {
   if (typeof RTCPeerConnection === 'undefined') {
     return false;
@@ -12276,6 +13470,9 @@ function createAudioAnalyser(track, options) {
     cleanup
   };
 }
+function isAudioCodec(maybeCodec) {
+  return audioCodecs.includes(maybeCodec);
+}
 function isVideoCodec(maybeCodec) {
   return videoCodecs.includes(maybeCodec);
 }
@@ -12570,8 +13767,16 @@ function getNewAudioContext() {
           }
         } catch (e) {
           console.warn('Error trying to auto-resume audio context', e);
+        } finally {
+          (_a = window.document.body) === null || _a === void 0 ? void 0 : _a.removeEventListener('click', handleResume);
+        }
+      });
+      // https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/statechange_event
+      audioContext.addEventListener('statechange', () => {
+        var _a;
+        if (audioContext.state === 'closed') {
+          (_a = window.document.body) === null || _a === void 0 ? void 0 : _a.removeEventListener('click', handleResume);
         }
-        (_a = window.document.body) === null || _a === void 0 ? void 0 : _a.removeEventListener('click', handleResume);
       });
       window.document.body.addEventListener('click', handleResume);
     }
@@ -12754,8 +13959,10 @@ function layerDimensionsFor(trackInfo, quality) {
  * @experimental
  */
 class E2EEManager extends eventsExports.EventEmitter {
-  constructor(options) {
+  constructor(options, dcEncryptionEnabled) {
     super();
+    this.decryptDataRequests = new Map();
+    this.encryptDataRequests = new Map();
     this.onWorkerMessage = ev => {
       var _a, _b;
       const {
@@ -12794,6 +14001,18 @@ class E2EEManager extends eventsExports.EventEmitter {
         case 'ratchetKey':
           this.keyProvider.emit(KeyProviderEvent.KeyRatcheted, data.ratchetResult, data.participantIdentity, data.keyIndex);
           break;
+        case 'decryptDataResponse':
+          const decryptFuture = this.decryptDataRequests.get(data.uuid);
+          if (decryptFuture === null || decryptFuture === void 0 ? void 0 : decryptFuture.resolve) {
+            decryptFuture.resolve(data);
+          }
+          break;
+        case 'encryptDataResponse':
+          const encryptFuture = this.encryptDataRequests.get(data.uuid);
+          if (encryptFuture === null || encryptFuture === void 0 ? void 0 : encryptFuture.resolve) {
+            encryptFuture.resolve(data);
+          }
+          break;
       }
     };
     this.onWorkerError = ev => {
@@ -12805,6 +14024,13 @@ class E2EEManager extends eventsExports.EventEmitter {
     this.keyProvider = options.keyProvider;
     this.worker = options.worker;
     this.encryptionEnabled = false;
+    this.dataChannelEncryptionEnabled = dcEncryptionEnabled;
+  }
+  get isEnabled() {
+    return this.encryptionEnabled;
+  }
+  get isDataChannelEncryptionEnabled() {
+    return this.isEnabled && this.dataChannelEncryptionEnabled;
   }
   /**
    * @internal
@@ -12908,6 +14134,52 @@ class E2EEManager extends eventsExports.EventEmitter {
     });
     keyProvider.on(KeyProviderEvent.SetKey, keyInfo => this.postKey(keyInfo)).on(KeyProviderEvent.RatchetRequest, (participantId, keyIndex) => this.postRatchetRequest(participantId, keyIndex));
   }
+  encryptData(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.worker) {
+        throw Error('could not encrypt data, worker is missing');
+      }
+      const uuid = crypto.randomUUID();
+      const msg = {
+        kind: 'encryptDataRequest',
+        data: {
+          uuid,
+          payload: data,
+          participantIdentity: this.room.localParticipant.identity
+        }
+      };
+      const future = new Future();
+      future.onFinally = () => {
+        this.encryptDataRequests.delete(uuid);
+      };
+      this.encryptDataRequests.set(uuid, future);
+      this.worker.postMessage(msg);
+      return future.promise;
+    });
+  }
+  handleEncryptedData(payload, iv, participantIdentity, keyIndex) {
+    if (!this.worker) {
+      throw Error('could not handle encrypted data, worker is missing');
+    }
+    const uuid = crypto.randomUUID();
+    const msg = {
+      kind: 'decryptDataRequest',
+      data: {
+        uuid,
+        payload,
+        iv,
+        participantIdentity,
+        keyIndex
+      }
+    };
+    const future = new Future();
+    future.onFinally = () => {
+      this.decryptDataRequests.delete(uuid);
+    };
+    this.decryptDataRequests.set(uuid, future);
+    this.worker.postMessage(msg);
+    return future.promise;
+  }
   postRatchetRequest(participantIdentity, keyIndex) {
     if (!this.worker) {
       throw Error('could not ratchet key, worker is missing');
@@ -13245,6 +14517,102 @@ class AsyncQueue {
   }
 }
 
+/**
+ * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
+ *
+ * @see https://web.dev/websocketstream/
+ */
+class WebSocketStream {
+  get readyState() {
+    return this.ws.readyState;
+  }
+  constructor(url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var _a, _b;
+    if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+      throw new DOMException('This operation was aborted', 'AbortError');
+    }
+    this.url = url;
+    const ws = new WebSocket(url, (_b = options.protocols) !== null && _b !== void 0 ? _b : []);
+    ws.binaryType = 'arraybuffer';
+    this.ws = ws;
+    const closeWithInfo = function () {
+      let {
+        closeCode: code,
+        reason
+      } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return ws.close(code, reason);
+    };
+    this.opened = new Promise((resolve, reject) => {
+      ws.onopen = () => {
+        resolve({
+          readable: new ReadableStream({
+            start(controller) {
+              ws.onmessage = _ref => {
+                let {
+                  data
+                } = _ref;
+                return controller.enqueue(data);
+              };
+              ws.onerror = e => controller.error(e);
+            },
+            cancel: closeWithInfo
+          }),
+          writable: new WritableStream({
+            write(chunk) {
+              ws.send(chunk);
+            },
+            abort() {
+              ws.close();
+            },
+            close: closeWithInfo
+          }),
+          protocol: ws.protocol,
+          extensions: ws.extensions
+        });
+        ws.removeEventListener('error', reject);
+      };
+      ws.addEventListener('error', reject);
+    });
+    this.closed = new Promise((resolve, reject) => {
+      const rejectHandler = () => __awaiter(this, void 0, void 0, function* () {
+        const closePromise = new Promise(res => {
+          if (ws.readyState === WebSocket.CLOSED) return;else {
+            ws.addEventListener('close', closeEv => {
+              res(closeEv);
+            }, {
+              once: true
+            });
+          }
+        });
+        const reason = yield Promise.race([sleep(250), closePromise]);
+        if (!reason) {
+          reject(new Error('Encountered unspecified websocket error without a timely close event'));
+        } else {
+          // if we can infer the close reason from the close event then resolve the promise, we don't need to throw
+          resolve(reason);
+        }
+      });
+      ws.onclose = _ref2 => {
+        let {
+          code,
+          reason
+        } = _ref2;
+        resolve({
+          closeCode: code,
+          reason
+        });
+        ws.removeEventListener('error', rejectHandler);
+      };
+      ws.addEventListener('error', rejectHandler);
+    });
+    if (options.signal) {
+      options.signal.onabort = () => ws.close();
+    }
+    this.close = closeWithInfo;
+  }
+}
+
 function createRtcUrl(url, searchParams) {
   const urlObj = new URL(toWebsocketUrl(url));
   searchParams.forEach((value, key) => {
@@ -13263,6 +14631,16 @@ function appendUrlPath(urlObj, path) {
   urlObj.pathname = "".concat(ensureTrailingSlash(urlObj.pathname)).concat(path);
   return urlObj.toString();
 }
+function parseSignalResponse(value) {
+  if (typeof value === 'string') {
+    return SignalResponse.fromJson(JSON.parse(value), {
+      ignoreUnknownFields: true
+    });
+  } else if (value instanceof ArrayBuffer) {
+    return SignalResponse.fromBinary(new Uint8Array(value));
+  }
+  throw new Error("could not decode websocket message: ".concat(typeof value));
+}
 
 const passThroughQueueSignals = ['syncState', 'trickle', 'offer', 'answer', 'simulate', 'leave'];
 function canPassThroughQueue(req) {
@@ -13281,6 +14659,8 @@ var SignalConnectionState;
   SignalConnectionState[SignalConnectionState["DISCONNECTING"] = 3] = "DISCONNECTING";
   SignalConnectionState[SignalConnectionState["DISCONNECTED"] = 4] = "DISCONNECTED";
 })(SignalConnectionState || (SignalConnectionState = {}));
+/** specifies how much time (in ms) we allow for the ws to close its connection gracefully before continuing */
+const MAX_WS_CLOSE_TIME = 250;
 /** @internal */
 class SignalClient {
   get currentState() {
@@ -13318,6 +14698,7 @@ class SignalClient {
       this.onTokenRefresh = undefined;
       this.onTrickle = undefined;
       this.onClose = undefined;
+      this.onMediaSectionsRequirement = undefined;
     };
     this.log = getLogger((_a = loggerOptions.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.Signal);
     this.loggerContextCb = loggerOptions.loggerContextCb;
@@ -13360,137 +14741,140 @@ class SignalClient {
     });
   }
   connect(url, token, opts, abortSignal) {
-    this.connectOptions = opts;
-    const clientInfo = getClientInfo();
-    const params = createConnectionParams(token, clientInfo, opts);
-    const rtcUrl = createRtcUrl(url, params);
-    const validateUrl = createValidateUrl(rtcUrl);
-    return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
       const unlock = yield this.connectionLock.lock();
-      try {
-        const abortHandler = () => __awaiter(this, void 0, void 0, function* () {
-          this.close();
-          clearTimeout(wsTimeout);
-          reject(new ConnectionError('room connection has been cancelled (signal)', ConnectionErrorReason.Cancelled));
-        });
-        const wsTimeout = setTimeout(() => {
-          this.close();
-          reject(new ConnectionError('room connection has timed out (signal)', ConnectionErrorReason.ServerUnreachable));
-        }, opts.websocketTimeout);
-        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
-          abortHandler();
-        }
-        abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener('abort', abortHandler);
-        const redactedUrl = new URL(rtcUrl);
-        if (redactedUrl.searchParams.has('access_token')) {
-          redactedUrl.searchParams.set('access_token', '<redacted>');
-        }
-        this.log.debug("connecting to ".concat(redactedUrl), Object.assign({
-          reconnect: opts.reconnect,
-          reconnectReason: opts.reconnectReason
-        }, this.logContext));
-        if (this.ws) {
-          yield this.close(false);
-        }
-        this.ws = new WebSocket(rtcUrl);
-        this.ws.binaryType = 'arraybuffer';
-        this.ws.onopen = () => {
-          clearTimeout(wsTimeout);
-        };
-        this.ws.onerror = ev => __awaiter(this, void 0, void 0, function* () {
-          if (this.state !== SignalConnectionState.CONNECTED) {
-            this.state = SignalConnectionState.DISCONNECTED;
+      this.connectOptions = opts;
+      const clientInfo = getClientInfo();
+      const params = opts.singlePeerConnection ? createJoinRequestConnectionParams(token, clientInfo, opts) : createConnectionParams(token, clientInfo, opts);
+      const rtcUrl = createRtcUrl(url, params);
+      const validateUrl = createValidateUrl(rtcUrl);
+      return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+          const timeoutAbortController = new AbortController();
+          const signals = abortSignal ? [timeoutAbortController.signal, abortSignal] : [timeoutAbortController.signal];
+          const combinedAbort = AbortSignal.any(signals);
+          const abortHandler = event => __awaiter(this, void 0, void 0, function* () {
+            this.close();
             clearTimeout(wsTimeout);
-            try {
-              const resp = yield fetch(validateUrl);
-              if (resp.status.toFixed(0).startsWith('4')) {
-                const msg = yield resp.text();
-                reject(new ConnectionError(msg, ConnectionErrorReason.NotAllowed, resp.status));
-              } else {
-                reject(new ConnectionError("Encountered unknown websocket error during connection: ".concat(ev.toString()), ConnectionErrorReason.InternalError, resp.status));
-              }
-            } catch (e) {
-              reject(new ConnectionError(e instanceof Error ? e.message : 'server was not reachable', ConnectionErrorReason.ServerUnreachable));
-            }
-            return;
+            const target = event.currentTarget;
+            reject(target instanceof AbortSignal ? target.reason : target);
+          });
+          combinedAbort.addEventListener('abort', abortHandler);
+          const wsTimeout = setTimeout(() => {
+            timeoutAbortController.abort(new ConnectionError('room connection has timed out (signal)', ConnectionErrorReason.ServerUnreachable));
+          }, opts.websocketTimeout);
+          const handleSignalConnected = (connection, firstMessage) => {
+            this.handleSignalConnected(connection, wsTimeout, firstMessage);
+          };
+          const redactedUrl = new URL(rtcUrl);
+          if (redactedUrl.searchParams.has('access_token')) {
+            redactedUrl.searchParams.set('access_token', '<redacted>');
           }
-          // other errors, handle
-          this.handleWSError(ev);
-        });
-        this.ws.onmessage = ev => __awaiter(this, void 0, void 0, function* () {
-          var _a, _b, _c;
-          // not considered connected until JoinResponse is received
-          let resp;
-          if (typeof ev.data === 'string') {
-            const json = JSON.parse(ev.data);
-            resp = SignalResponse.fromJson(json, {
-              ignoreUnknownFields: true
-            });
-          } else if (ev.data instanceof ArrayBuffer) {
-            resp = SignalResponse.fromBinary(new Uint8Array(ev.data));
-          } else {
-            this.log.error("could not decode websocket message: ".concat(typeof ev.data), this.logContext);
-            return;
+          this.log.debug("connecting to ".concat(redactedUrl), Object.assign({
+            reconnect: opts.reconnect,
+            reconnectReason: opts.reconnectReason
+          }, this.logContext));
+          if (this.ws) {
+            yield this.close(false);
           }
-          if (this.state !== SignalConnectionState.CONNECTED) {
-            let shouldProcessMessage = false;
-            // handle join message only
-            if (((_a = resp.message) === null || _a === void 0 ? void 0 : _a.case) === 'join') {
-              this.state = SignalConnectionState.CONNECTED;
-              abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener('abort', abortHandler);
-              this.pingTimeoutDuration = resp.message.value.pingTimeout;
-              this.pingIntervalDuration = resp.message.value.pingInterval;
+          this.ws = new WebSocketStream(rtcUrl, {
+            signal: combinedAbort
+          });
+          try {
+            this.ws.closed.then(closeInfo => {
+              if (this.isEstablishingConnection) {
+                reject(new ConnectionError("Websocket got closed during a (re)connection attempt: ".concat(closeInfo.reason), ConnectionErrorReason.InternalError));
+              }
+              if (closeInfo.closeCode !== 1000) {
+                this.log.warn("websocket closed", Object.assign(Object.assign({}, this.logContext), {
+                  reason: closeInfo.reason,
+                  code: closeInfo.closeCode,
+                  wasClean: closeInfo.closeCode === 1000,
+                  state: this.state
+                }));
+              }
+              return;
+            }).catch(reason => {
+              if (this.isEstablishingConnection) {
+                reject(new ConnectionError("Websocket error during a (re)connection attempt: ".concat(reason), ConnectionErrorReason.InternalError));
+              }
+            });
+            const connection = yield this.ws.opened.catch(reason => __awaiter(this, void 0, void 0, function* () {
+              if (this.state !== SignalConnectionState.CONNECTED) {
+                this.state = SignalConnectionState.DISCONNECTED;
+                clearTimeout(wsTimeout);
+                const error = yield this.handleConnectionError(reason, validateUrl);
+                reject(error);
+                return;
+              }
+              // other errors, handle
+              this.handleWSError(reason);
+              reject(reason);
+              return;
+            }));
+            clearTimeout(wsTimeout);
+            if (!connection) {
+              return;
+            }
+            const signalReader = connection.readable.getReader();
+            const firstMessage = yield signalReader.read();
+            signalReader.releaseLock();
+            if (!firstMessage.value) {
+              throw new ConnectionError('no message received as first message', ConnectionErrorReason.InternalError);
+            }
+            const firstSignalResponse = parseSignalResponse(firstMessage.value);
+            // Validate the first message
+            const validation = this.validateFirstMessage(firstSignalResponse, (_a = opts.reconnect) !== null && _a !== void 0 ? _a : false);
+            if (!validation.isValid) {
+              reject(validation.error);
+              return;
+            }
+            // Handle join response - set up ping configuration
+            if (((_b = firstSignalResponse.message) === null || _b === void 0 ? void 0 : _b.case) === 'join') {
+              this.pingTimeoutDuration = firstSignalResponse.message.value.pingTimeout;
+              this.pingIntervalDuration = firstSignalResponse.message.value.pingInterval;
               if (this.pingTimeoutDuration && this.pingTimeoutDuration > 0) {
                 this.log.debug('ping config', Object.assign(Object.assign({}, this.logContext), {
                   timeout: this.pingTimeoutDuration,
                   interval: this.pingIntervalDuration
                 }));
-                this.startPingInterval();
-              }
-              resolve(resp.message.value);
-            } else if (this.state === SignalConnectionState.RECONNECTING && resp.message.case !== 'leave') {
-              // in reconnecting, any message received means signal reconnected
-              this.state = SignalConnectionState.CONNECTED;
-              abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener('abort', abortHandler);
-              this.startPingInterval();
-              if (((_b = resp.message) === null || _b === void 0 ? void 0 : _b.case) === 'reconnect') {
-                resolve(resp.message.value);
-              } else {
-                this.log.debug('declaring signal reconnected without reconnect response received', this.logContext);
-                resolve(undefined);
-                shouldProcessMessage = true;
               }
-            } else if (this.isEstablishingConnection && resp.message.case === 'leave') {
-              reject(new ConnectionError('Received leave request while trying to (re)connect', ConnectionErrorReason.LeaveRequest, undefined, resp.message.value.reason));
-            } else if (!opts.reconnect) {
-              // non-reconnect case, should receive join response first
-              reject(new ConnectionError("did not receive join response, got ".concat((_c = resp.message) === null || _c === void 0 ? void 0 : _c.case, " instead"), ConnectionErrorReason.InternalError));
             }
-            if (!shouldProcessMessage) {
-              return;
-            }
-          }
-          if (this.signalLatency) {
-            yield sleep(this.signalLatency);
-          }
-          this.handleSignalResponse(resp);
-        });
-        this.ws.onclose = ev => {
-          if (this.isEstablishingConnection) {
-            reject(new ConnectionError('Websocket got closed during a (re)connection attempt', ConnectionErrorReason.InternalError));
+            // Handle successful connection
+            const firstMessageToProcess = validation.shouldProcessFirstMessage ? firstSignalResponse : undefined;
+            handleSignalConnected(connection, firstMessageToProcess);
+            resolve(validation.response);
+          } catch (e) {
+            clearTimeout(wsTimeout);
+            reject(e);
           }
-          this.log.warn("websocket closed", Object.assign(Object.assign({}, this.logContext), {
-            reason: ev.reason,
-            code: ev.code,
-            wasClean: ev.wasClean,
-            state: this.state
-          }));
-          this.handleOnClose(ev.reason);
-        };
-      } finally {
-        unlock();
+        } finally {
+          unlock();
+        }
+      }));
+    });
+  }
+  startReadingLoop(signalReader, firstMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (firstMessage) {
+        this.handleSignalResponse(firstMessage);
       }
-    }));
+      while (true) {
+        if (this.signalLatency) {
+          yield sleep(this.signalLatency);
+        }
+        const {
+          done,
+          value
+        } = yield signalReader.read();
+        if (done) {
+          break;
+        }
+        const resp = parseSignalResponse(value);
+        this.handleSignalResponse(resp);
+      }
+    });
   }
   close() {
     return __awaiter(this, arguments, void 0, function () {
@@ -13504,26 +14888,20 @@ class SignalClient {
             _this.state = SignalConnectionState.DISCONNECTING;
           }
           if (_this.ws) {
-            _this.ws.onmessage = null;
-            _this.ws.onopen = null;
-            _this.ws.onclose = null;
-            // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
-            const closePromise = new Promise(resolve => {
-              if (_this.ws) {
-                _this.ws.onclose = () => {
-                  resolve();
-                };
-              } else {
-                resolve();
-              }
+            _this.ws.close({
+              closeCode: 1000,
+              reason: 'Close method called on signal client'
             });
-            if (_this.ws.readyState < _this.ws.CLOSING) {
-              _this.ws.close();
-              // 250ms grace period for ws to close gracefully
-              yield Promise.race([closePromise, sleep(250)]);
-            }
+            // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
+            const closePromise = _this.ws.closed;
             _this.ws = undefined;
+            _this.streamWriter = undefined;
+            yield Promise.race([closePromise, sleep(MAX_WS_CLOSE_TIME)]);
           }
+        } catch (e) {
+          _this.log.debug('websocket error while closing', Object.assign(Object.assign({}, _this.logContext), {
+            error: e
+          }));
         } finally {
           if (updateState) {
             _this.state = SignalConnectionState.DISCONNECTED;
@@ -13700,7 +15078,7 @@ class SignalClient {
           _this3.log.debug("skipping signal request (type: ".concat(message.case, ") - SignalClient disconnected"));
           return;
         }
-        if (!_this3.ws || _this3.ws.readyState !== _this3.ws.OPEN) {
+        if (!_this3.streamWriter) {
           _this3.log.error("cannot send signal request before connected, type: ".concat(message === null || message === void 0 ? void 0 : message.case), _this3.logContext);
           return;
         }
@@ -13709,9 +15087,9 @@ class SignalClient {
         });
         try {
           if (_this3.useJSON) {
-            _this3.ws.send(req.toJsonString());
+            yield _this3.streamWriter.write(req.toJsonString());
           } else {
-            _this3.ws.send(req.toBinary());
+            yield _this3.streamWriter.write(req.toBinary());
           }
         } catch (e) {
           _this3.log.error('error sending signal message', Object.assign(Object.assign({}, _this3.logContext), {
@@ -13815,6 +15193,10 @@ class SignalClient {
       if (this.onRoomMoved) {
         this.onRoomMoved(msg.value);
       }
+    } else if (msg.case === 'mediaSectionsRequirement') {
+      if (this.onMediaSectionsRequirement) {
+        this.onMediaSectionsRequirement(msg.value);
+      }
     } else {
       this.log.debug('unsupported message', Object.assign(Object.assign({}, this.logContext), {
         msgCase: msg.case
@@ -13845,9 +15227,9 @@ class SignalClient {
       }
     });
   }
-  handleWSError(ev) {
+  handleWSError(error) {
     this.log.error('websocket error', Object.assign(Object.assign({}, this.logContext), {
-      error: ev
+      error
     }));
   }
   /**
@@ -13892,6 +15274,90 @@ class SignalClient {
       CriticalTimers.clearInterval(this.pingInterval);
     }
   }
+  /**
+   * Handles the successful connection to the signal server
+   * @param connection The WebSocket connection
+   * @param timeoutHandle The timeout handle to clear
+   * @param firstMessage Optional first message to process
+   * @internal
+   */
+  handleSignalConnected(connection, timeoutHandle, firstMessage) {
+    this.state = SignalConnectionState.CONNECTED;
+    clearTimeout(timeoutHandle);
+    this.startPingInterval();
+    this.startReadingLoop(connection.readable.getReader(), firstMessage);
+    this.streamWriter = connection.writable.getWriter();
+  }
+  /**
+   * Validates the first message received from the signal server
+   * @param firstSignalResponse The first signal response received
+   * @param isReconnect Whether this is a reconnection attempt
+   * @returns Validation result with response or error
+   * @internal
+   */
+  validateFirstMessage(firstSignalResponse, isReconnect) {
+    var _a, _b, _c, _d, _e;
+    if (((_a = firstSignalResponse.message) === null || _a === void 0 ? void 0 : _a.case) === 'join') {
+      return {
+        isValid: true,
+        response: firstSignalResponse.message.value
+      };
+    } else if (this.state === SignalConnectionState.RECONNECTING && ((_b = firstSignalResponse.message) === null || _b === void 0 ? void 0 : _b.case) !== 'leave') {
+      if (((_c = firstSignalResponse.message) === null || _c === void 0 ? void 0 : _c.case) === 'reconnect') {
+        return {
+          isValid: true,
+          response: firstSignalResponse.message.value
+        };
+      } else {
+        // in reconnecting, any message received means signal reconnected and we still need to process it
+        this.log.debug('declaring signal reconnected without reconnect response received', this.logContext);
+        return {
+          isValid: true,
+          response: undefined,
+          shouldProcessFirstMessage: true
+        };
+      }
+    } else if (this.isEstablishingConnection && ((_d = firstSignalResponse.message) === null || _d === void 0 ? void 0 : _d.case) === 'leave') {
+      return {
+        isValid: false,
+        error: new ConnectionError('Received leave request while trying to (re)connect', ConnectionErrorReason.LeaveRequest, undefined, firstSignalResponse.message.value.reason)
+      };
+    } else if (!isReconnect) {
+      // non-reconnect case, should receive join response first
+      return {
+        isValid: false,
+        error: new ConnectionError("did not receive join response, got ".concat((_e = firstSignalResponse.message) === null || _e === void 0 ? void 0 : _e.case, " instead"), ConnectionErrorReason.InternalError)
+      };
+    }
+    return {
+      isValid: false,
+      error: new ConnectionError('Unexpected first message', ConnectionErrorReason.InternalError)
+    };
+  }
+  /**
+   * Handles WebSocket connection errors by validating with the server
+   * @param reason The error that occurred
+   * @param validateUrl The URL to validate the connection with
+   * @returns A ConnectionError with appropriate reason and status
+   * @internal
+   */
+  handleConnectionError(reason, validateUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+      try {
+        const resp = yield fetch(validateUrl);
+        if (resp.status.toFixed(0).startsWith('4')) {
+          const msg = yield resp.text();
+          return new ConnectionError(msg, ConnectionErrorReason.NotAllowed, resp.status);
+        } else if (reason instanceof ConnectionError) {
+          return reason;
+        } else {
+          return new ConnectionError("Encountered unknown websocket error during connection: ".concat(reason), ConnectionErrorReason.InternalError, resp.status);
+        }
+      } catch (e) {
+        return e instanceof ConnectionError ? e : new ConnectionError(e instanceof Error ? e.message : 'server was not reachable', ConnectionErrorReason.ServerUnreachable);
+      }
+    });
+  }
 }
 function fromProtoSessionDescription(sd) {
   const rsd = {
@@ -13960,6 +15426,27 @@ function createConnectionParams(token, info, opts) {
   }
   return params;
 }
+function createJoinRequestConnectionParams(token, info, opts) {
+  const params = new URLSearchParams();
+  params.set('access_token', token);
+  const joinRequest = new JoinRequest({
+    clientInfo: info,
+    connectionSettings: new ConnectionSettings({
+      autoSubscribe: !!opts.autoSubscribe,
+      adaptiveStream: !!opts.adaptiveStream
+    }),
+    reconnect: !!opts.reconnect,
+    participantSid: opts.sid ? opts.sid : undefined
+  });
+  if (opts.reconnectReason) {
+    joinRequest.reconnectReason = opts.reconnectReason;
+  }
+  const wrappedJoinRequest = new WrappedJoinRequest({
+    joinRequest: joinRequest.toBinary()
+  });
+  params.set('join_request', btoa(new TextDecoder('utf-8').decode(wrappedJoinRequest.toBinary())));
+  return params;
+}
 
 class DataPacketBuffer {
   constructor() {
@@ -14972,7 +16459,7 @@ class PCTransport extends eventsExports.EventEmitter {
         sdpParsed.media.forEach(media => {
           const mid = getMidString(media.mid);
           if (media.type === 'audio') {
-            // mung sdp for opus bitrate settings
+            // munge sdp for opus bitrate settings
             this.trackBitrates.some(trackbr => {
               if (!trackbr.transceiver || mid != trackbr.transceiver.mid) {
                 return false;
@@ -15077,7 +16564,7 @@ class PCTransport extends eventsExports.EventEmitter {
         sdpParsed.media.forEach(media => {
           ensureIPAddrMatchVersion(media);
           if (media.type === 'audio') {
-            ensureAudioNackAndStereo(media, [], []);
+            ensureAudioNackAndStereo(media, ['all'], []);
           } else if (media.type === 'video') {
             this.trackBitrates.some(trackbr => {
               if (!media.msid || !trackbr.cid || !media.msid.includes(trackbr.cid)) {
@@ -15153,6 +16640,9 @@ class PCTransport extends eventsExports.EventEmitter {
   addTransceiver(mediaStreamTrack, transceiverInit) {
     return this.pc.addTransceiver(mediaStreamTrack, transceiverInit);
   }
+  addTransceiverOfKind(kind, transceiverInit) {
+    return this.pc.addTransceiver(kind, transceiverInit);
+  }
   addTrack(track) {
     if (!this._pc) {
       throw new UnexpectedConnectionState('PC closed, cannot add track');
@@ -15347,7 +16837,7 @@ function ensureAudioNackAndStereo(media, stereoMids, nackMids) {
         type: 'nack'
       });
     }
-    if (stereoMids.includes(mid)) {
+    if (stereoMids.includes(mid) || stereoMids.length === 1 && stereoMids[0] === 'all') {
       media.fmtp.some(fmtp => {
         if (fmtp.payload === opusPayload) {
           if (!fmtp.config.includes('stereo=1')) {
@@ -15447,7 +16937,8 @@ const roomOptionDefaults = {
   stopLocalTrackOnUnpublish: true,
   reconnectPolicy: new DefaultReconnectPolicy(),
   disconnectOnPageLeave: true,
-  webAudioMix: false
+  webAudioMix: false,
+  singlePeerConnection: false
 };
 const roomConnectOptionDefaults = {
   autoSubscribe: true,
@@ -15475,12 +16966,12 @@ class PCTransportManager {
   get currentState() {
     return this.state;
   }
-  constructor(rtcConfig, subscriberPrimary, loggerOptions) {
+  constructor(rtcConfig, mode, loggerOptions) {
     var _a;
     this.peerConnectionTimeout = roomConnectOptionDefaults.peerConnectionTimeout;
     this.log = livekitLogger;
     this.updateState = () => {
-      var _a;
+      var _a, _b;
       const previousState = this.state;
       const connectionStates = this.requiredTransports.map(tr => tr.getConnectionState());
       if (connectionStates.every(st => st === 'connected')) {
@@ -15498,35 +16989,41 @@ class PCTransportManager {
       }
       if (previousState !== this.state) {
         this.log.debug("pc state change: from ".concat(PCTransportState[previousState], " to ").concat(PCTransportState[this.state]), this.logContext);
-        (_a = this.onStateChange) === null || _a === void 0 ? void 0 : _a.call(this, this.state, this.publisher.getConnectionState(), this.subscriber.getConnectionState());
+        (_a = this.onStateChange) === null || _a === void 0 ? void 0 : _a.call(this, this.state, this.publisher.getConnectionState(), (_b = this.subscriber) === null || _b === void 0 ? void 0 : _b.getConnectionState());
       }
     };
     this.log = getLogger((_a = loggerOptions.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.PCManager);
     this.loggerOptions = loggerOptions;
-    this.isPublisherConnectionRequired = !subscriberPrimary;
-    this.isSubscriberConnectionRequired = subscriberPrimary;
+    this.isPublisherConnectionRequired = mode !== 'subscriber-primary';
+    this.isSubscriberConnectionRequired = mode === 'subscriber-primary';
     this.publisher = new PCTransport(rtcConfig, loggerOptions);
-    this.subscriber = new PCTransport(rtcConfig, loggerOptions);
+    if (mode !== 'publisher-only') {
+      this.subscriber = new PCTransport(rtcConfig, loggerOptions);
+      this.subscriber.onConnectionStateChange = this.updateState;
+      this.subscriber.onIceConnectionStateChange = this.updateState;
+      this.subscriber.onSignalingStatechange = this.updateState;
+      this.subscriber.onIceCandidate = candidate => {
+        var _a;
+        (_a = this.onIceCandidate) === null || _a === void 0 ? void 0 : _a.call(this, candidate, SignalTarget.SUBSCRIBER);
+      };
+      // in subscriber primary mode, server side opens sub data channels.
+      this.subscriber.onDataChannel = ev => {
+        var _a;
+        (_a = this.onDataChannel) === null || _a === void 0 ? void 0 : _a.call(this, ev);
+      };
+      this.subscriber.onTrack = ev => {
+        var _a;
+        (_a = this.onTrack) === null || _a === void 0 ? void 0 : _a.call(this, ev);
+      };
+    }
     this.publisher.onConnectionStateChange = this.updateState;
-    this.subscriber.onConnectionStateChange = this.updateState;
     this.publisher.onIceConnectionStateChange = this.updateState;
-    this.subscriber.onIceConnectionStateChange = this.updateState;
     this.publisher.onSignalingStatechange = this.updateState;
-    this.subscriber.onSignalingStatechange = this.updateState;
     this.publisher.onIceCandidate = candidate => {
       var _a;
       (_a = this.onIceCandidate) === null || _a === void 0 ? void 0 : _a.call(this, candidate, SignalTarget.PUBLISHER);
     };
-    this.subscriber.onIceCandidate = candidate => {
-      var _a;
-      (_a = this.onIceCandidate) === null || _a === void 0 ? void 0 : _a.call(this, candidate, SignalTarget.SUBSCRIBER);
-    };
-    // in subscriber primary mode, server side opens sub data channels.
-    this.subscriber.onDataChannel = ev => {
-      var _a;
-      (_a = this.onDataChannel) === null || _a === void 0 ? void 0 : _a.call(this, ev);
-    };
-    this.subscriber.onTrack = ev => {
+    this.publisher.onTrack = ev => {
       var _a;
       (_a = this.onTrack) === null || _a === void 0 ? void 0 : _a.call(this, ev);
     };
@@ -15547,11 +17044,6 @@ class PCTransportManager {
     this.isPublisherConnectionRequired = require;
     this.updateState();
   }
-  requireSubscriber() {
-    let require = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-    this.isSubscriberConnectionRequired = require;
-    this.updateState();
-  }
   createAndSendPublisherOffer(options) {
     return this.publisher.createAndSendOffer(options);
   }
@@ -15563,6 +17055,7 @@ class PCTransportManager {
   }
   close() {
     return __awaiter(this, void 0, void 0, function* () {
+      var _a;
       if (this.publisher && this.publisher.getSignallingState() !== 'closed') {
         const publisher = this.publisher;
         for (const sender of publisher.getSenders()) {
@@ -15578,13 +17071,15 @@ class PCTransportManager {
           }
         }
       }
-      yield Promise.all([this.publisher.close(), this.subscriber.close()]);
+      yield Promise.all([this.publisher.close(), (_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.close()]);
       this.updateState();
     });
   }
   triggerIceRestart() {
     return __awaiter(this, void 0, void 0, function* () {
-      this.subscriber.restartingIce = true;
+      if (this.subscriber) {
+        this.subscriber.restartingIce = true;
+      }
       // only restart publisher if it's needed
       if (this.needsPublisher) {
         yield this.createAndSendPublisherOffer({
@@ -15595,28 +17090,30 @@ class PCTransportManager {
   }
   addIceCandidate(candidate, target) {
     return __awaiter(this, void 0, void 0, function* () {
+      var _a;
       if (target === SignalTarget.PUBLISHER) {
         yield this.publisher.addIceCandidate(candidate);
       } else {
-        yield this.subscriber.addIceCandidate(candidate);
+        yield (_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.addIceCandidate(candidate);
       }
     });
   }
   createSubscriberAnswerFromOffer(sd, offerId) {
     return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b, _c;
       this.log.debug('received server offer', Object.assign(Object.assign({}, this.logContext), {
         RTCSdpType: sd.type,
         sdp: sd.sdp,
-        signalingState: this.subscriber.getSignallingState().toString()
+        signalingState: (_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.getSignallingState().toString()
       }));
       const unlock = yield this.remoteOfferLock.lock();
       try {
-        const success = yield this.subscriber.setRemoteDescription(sd, offerId);
+        const success = yield (_b = this.subscriber) === null || _b === void 0 ? void 0 : _b.setRemoteDescription(sd, offerId);
         if (!success) {
           return undefined;
         }
         // answer the offer
-        const answer = yield this.subscriber.createAndSetAnswer();
+        const answer = yield (_c = this.subscriber) === null || _c === void 0 ? void 0 : _c.createAndSetAnswer();
         return answer;
       } finally {
         unlock();
@@ -15624,8 +17121,9 @@ class PCTransportManager {
     });
   }
   updateConfiguration(config, iceRestart) {
+    var _a;
     this.publisher.setConfiguration(config);
-    this.subscriber.setConfiguration(config);
+    (_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.setConfiguration(config);
     if (iceRestart) {
       this.triggerIceRestart();
     }
@@ -15675,6 +17173,9 @@ class PCTransportManager {
   addPublisherTransceiver(track, transceiverInit) {
     return this.publisher.addTransceiver(track, transceiverInit);
   }
+  addPublisherTransceiverOfKind(kind, transceiverInit) {
+    return this.publisher.addTransceiverOfKind(kind, transceiverInit);
+  }
   addPublisherTrack(track) {
     return this.publisher.addTrack(track);
   }
@@ -15697,7 +17198,7 @@ class PCTransportManager {
     if (this.isPublisherConnectionRequired) {
       transports.push(this.publisher);
     }
-    if (this.isSubscriberConnectionRequired) {
+    if (this.isSubscriberConnectionRequired && this.subscriber) {
       transports.push(this.subscriber);
     }
     return transports;
@@ -16768,7 +18269,7 @@ class LocalAudioTrack extends LocalTrack {
       const trackIsSilent = yield detectSilence(this);
       if (trackIsSilent) {
         if (!this.isMuted) {
-          this.log.warn('silence detected on local audio track', this.logContext);
+          this.log.debug('silence detected on local audio track', this.logContext);
         }
         this.emit(TrackEvent.AudioSilenceDetected);
       }
@@ -17856,7 +19357,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       }();
     });
     this.handleDataMessage = message => __awaiter(this, void 0, void 0, function* () {
-      var _a, _b;
+      var _a, _b, _c, _d, _e;
       // make sure to respect incoming data message order by processing message events one after the other
       const unlock = yield this.dataProcessLock.lock();
       try {
@@ -17884,12 +19385,29 @@ class RTCEngine extends eventsExports.EventEmitter {
         if (((_a = dp.value) === null || _a === void 0 ? void 0 : _a.case) === 'speaker') {
           // dispatch speaker updates
           this.emit(EngineEvent.ActiveSpeakersUpdate, dp.value.value.speakers);
+        } else if (((_b = dp.value) === null || _b === void 0 ? void 0 : _b.case) === 'encryptedPacket') {
+          if (!this.e2eeManager) {
+            this.log.error('Received encrypted packet but E2EE not set up', this.logContext);
+            return;
+          }
+          const decryptedData = yield (_c = this.e2eeManager) === null || _c === void 0 ? void 0 : _c.handleEncryptedData(dp.value.value.encryptedValue, dp.value.value.iv, dp.participantIdentity, dp.value.value.keyIndex);
+          const decryptedPacket = EncryptedPacketPayload.fromBinary(decryptedData.payload);
+          const newDp = new DataPacket({
+            value: decryptedPacket.value,
+            participantIdentity: dp.participantIdentity,
+            participantSid: dp.participantSid
+          });
+          if (((_d = newDp.value) === null || _d === void 0 ? void 0 : _d.case) === 'user') {
+            // compatibility
+            applyUserDataCompat(newDp, newDp.value.value);
+          }
+          this.emit(EngineEvent.DataPacketReceived, newDp, dp.value.value.encryptionType);
         } else {
-          if (((_b = dp.value) === null || _b === void 0 ? void 0 : _b.case) === 'user') {
+          if (((_e = dp.value) === null || _e === void 0 ? void 0 : _e.case) === 'user') {
             // compatibility
             applyUserDataCompat(dp, dp.value.value);
           }
-          this.emit(EngineEvent.DataPacketReceived, dp);
+          this.emit(EngineEvent.DataPacketReceived, dp, Encryption_Type.NONE);
         }
       } finally {
         unlock();
@@ -18002,7 +19520,6 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.client = new SignalClient(undefined, this.loggerOptions);
     this.client.signalLatency = this.options.expSignalLatency;
     this.reconnectPolicy = this.options.reconnectPolicy;
-    this.registerOnLineListener();
     this.closingLock = new _();
     this.dataProcessLock = new _();
     this.dcBufferStatus = new Map([[DataPacket_Kind.LOSSY, true], [DataPacket_Kind.RELIABLE, true]]);
@@ -18043,8 +19560,11 @@ class RTCEngine extends eventsExports.EventEmitter {
         }
         // create offer
         if (!this.subscriberPrimary || joinResponse.fastPublish) {
-          this.negotiate();
+          this.negotiate().catch(err => {
+            livekitLogger.error(err, this.logContext);
+          });
         }
+        this.registerOnLineListener();
         this.clientConfiguration = joinResponse.clientConfiguration;
         this.emit(EngineEvent.SignalConnected, joinResponse);
         return joinResponse;
@@ -18190,7 +19710,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       }
       this.participantSid = (_a = joinResponse.participant) === null || _a === void 0 ? void 0 : _a.sid;
       const rtcConfig = this.makeRTCConfiguration(joinResponse);
-      this.pcManager = new PCTransportManager(rtcConfig, joinResponse.subscriberPrimary, this.loggerOptions);
+      this.pcManager = new PCTransportManager(rtcConfig, this.options.singlePeerConnection ? 'publisher-only' : joinResponse.subscriberPrimary ? 'subscriber-primary' : 'publisher-primary', this.loggerOptions);
       this.emit(EngineEvent.TransportsCreated, this.pcManager.publisher, this.pcManager.subscriber);
       this.pcManager.onIceCandidate = (candidate, target) => {
         this.client.sendIceCandidate(candidate, target);
@@ -18213,7 +19733,7 @@ class RTCEngine extends eventsExports.EventEmitter {
           }
         } else if (connectionState === PCTransportState.FAILED) {
           // on Safari, PeerConnection will switch to 'disconnected' during renegotiation
-          if (this.pcState === PCState.Connected) {
+          if (this.pcState === PCState.Connected || this.pcState === PCState.Reconnecting) {
             this.pcState = PCState.Disconnected;
             this.handleDisconnect('peerconnection failed', subscriberState === 'failed' ? ReconnectReason.RR_SUBSCRIBER_FAILED : ReconnectReason.RR_PUBLISHER_FAILED);
           }
@@ -18226,6 +19746,9 @@ class RTCEngine extends eventsExports.EventEmitter {
         }
       });
       this.pcManager.onTrack = ev => {
+        // this fires after the underlying transceiver is stopped and potentially
+        // peer connection closed, so do not bubble up if there are no streams
+        if (ev.streams.length === 0) return;
         this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
       };
       if (!supportOptionalDatachannel((_b = joinResponse.serverInfo) === null || _b === void 0 ? void 0 : _b.protocol)) {
@@ -18307,6 +19830,19 @@ class RTCEngine extends eventsExports.EventEmitter {
       }
       this.emit(EngineEvent.RoomMoved, res);
     };
+    this.client.onMediaSectionsRequirement = requirement => {
+      var _a, _b;
+      const transceiverInit = {
+        direction: 'recvonly'
+      };
+      for (let i = 0; i < requirement.numAudios; i++) {
+        (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.addPublisherTransceiverOfKind('audio', transceiverInit);
+      }
+      for (let i = 0; i < requirement.numVideos; i++) {
+        (_b = this.pcManager) === null || _b === void 0 ? void 0 : _b.addPublisherTransceiverOfKind('video', transceiverInit);
+      }
+      this.negotiate();
+    };
     this.client.onClose = () => {
       this.handleDisconnect('signal', ReconnectReason.RR_SIGNAL_DISCONNECTED);
     };
@@ -18734,6 +20270,20 @@ class RTCEngine extends eventsExports.EventEmitter {
     return __awaiter(this, void 0, void 0, function* () {
       // make sure we do have a data connection
       yield this.ensurePublisherConnected(kind);
+      if (this.e2eeManager && this.e2eeManager.isDataChannelEncryptionEnabled) {
+        const encryptablePacket = asEncryptablePacket(packet);
+        if (encryptablePacket) {
+          const encryptedData = yield this.e2eeManager.encryptData(encryptablePacket.toBinary());
+          packet.value = {
+            case: 'encryptedPacket',
+            value: new EncryptedPacket({
+              encryptedValue: encryptedData.payload,
+              iv: encryptedData.iv,
+              keyIndex: encryptedData.keyIndex
+            })
+          };
+        }
+      }
       if (kind === DataPacket_Kind.RELIABLE) {
         packet.sequence = this.reliableDataSequence;
         this.reliableDataSequence += 1;
@@ -18810,7 +20360,9 @@ class RTCEngine extends eventsExports.EventEmitter {
         }
         if (needNegotiation) {
           // start negotiation
-          _this2.negotiate();
+          _this2.negotiate().catch(err => {
+            livekitLogger.error(err, _this2.logContext);
+          });
         }
         const targetChannel = _this2.dataChannelForKind(kind, subscriber);
         if ((targetChannel === null || targetChannel === void 0 ? void 0 : targetChannel.readyState) === 'open') {
@@ -18920,19 +20472,21 @@ class RTCEngine extends eventsExports.EventEmitter {
   }
   /** @internal */
   sendSyncState(remoteTracks, localTracks) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     if (!this.pcManager) {
       this.log.warn('sync state cannot be sent without peer connection setup', this.logContext);
       return;
     }
-    const previousAnswer = this.pcManager.subscriber.getLocalDescription();
-    const previousOffer = this.pcManager.subscriber.getRemoteDescription();
+    const previousPublisherOffer = this.pcManager.publisher.getLocalDescription();
+    const previousPublisherAnswer = this.pcManager.publisher.getRemoteDescription();
+    const previousSubscriberOffer = (_a = this.pcManager.subscriber) === null || _a === void 0 ? void 0 : _a.getRemoteDescription();
+    const previousSubscriberAnswer = (_b = this.pcManager.subscriber) === null || _b === void 0 ? void 0 : _b.getLocalDescription();
     /* 1. autosubscribe on, so subscribed tracks = all tracks - unsub tracks,
           in this case, we send unsub tracks, so server add all tracks to this
           subscribe pc and unsub special tracks from it.
        2. autosubscribe off, we send subscribed tracks.
     */
-    const autoSubscribe = (_b = (_a = this.signalOpts) === null || _a === void 0 ? void 0 : _a.autoSubscribe) !== null && _b !== void 0 ? _b : true;
+    const autoSubscribe = (_d = (_c = this.signalOpts) === null || _c === void 0 ? void 0 : _c.autoSubscribe) !== null && _d !== void 0 ? _d : true;
     const trackSids = new Array();
     const trackSidsDisabled = new Array();
     remoteTracks.forEach(track => {
@@ -18944,13 +20498,19 @@ class RTCEngine extends eventsExports.EventEmitter {
       }
     });
     this.client.sendSyncState(new SyncState({
-      answer: previousAnswer ? toProtoSessionDescription({
-        sdp: previousAnswer.sdp,
-        type: previousAnswer.type
+      answer: this.options.singlePeerConnection ? previousPublisherAnswer ? toProtoSessionDescription({
+        sdp: previousPublisherAnswer.sdp,
+        type: previousPublisherAnswer.type
+      }) : undefined : previousSubscriberAnswer ? toProtoSessionDescription({
+        sdp: previousSubscriberAnswer.sdp,
+        type: previousSubscriberAnswer.type
       }) : undefined,
-      offer: previousOffer ? toProtoSessionDescription({
-        sdp: previousOffer.sdp,
-        type: previousOffer.type
+      offer: this.options.singlePeerConnection ? previousPublisherOffer ? toProtoSessionDescription({
+        sdp: previousPublisherOffer.sdp,
+        type: previousPublisherOffer.type
+      }) : undefined : previousSubscriberOffer ? toProtoSessionDescription({
+        sdp: previousSubscriberOffer.sdp,
+        type: previousSubscriberOffer.type
       }) : undefined,
       subscription: new UpdateSubscription({
         trackSids,
@@ -19427,21 +20987,21 @@ class IncomingDataStreamManager {
       }
     }
   }
-  handleDataStreamPacket(packet) {
+  handleDataStreamPacket(packet, encryptionType) {
     return __awaiter(this, void 0, void 0, function* () {
       switch (packet.value.case) {
         case 'streamHeader':
-          return this.handleStreamHeader(packet.value.value, packet.participantIdentity);
+          return this.handleStreamHeader(packet.value.value, packet.participantIdentity, encryptionType);
         case 'streamChunk':
-          return this.handleStreamChunk(packet.value.value);
+          return this.handleStreamChunk(packet.value.value, encryptionType);
         case 'streamTrailer':
-          return this.handleStreamTrailer(packet.value.value);
+          return this.handleStreamTrailer(packet.value.value, encryptionType);
         default:
           throw new Error("DataPacket of value \"".concat(packet.value.case, "\" is not data stream related!"));
       }
     });
   }
-  handleStreamHeader(streamHeader, participantIdentity) {
+  handleStreamHeader(streamHeader, participantIdentity, encryptionType) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
       if (streamHeader.contentHeader.case === 'byteHeader') {
@@ -19452,6 +21012,9 @@ class IncomingDataStreamManager {
         }
         let streamController;
         const outOfBandFailureRejectingFuture = new Future();
+        outOfBandFailureRejectingFuture.promise.catch(err => {
+          this.log.error(err);
+        });
         const info = {
           id: streamHeader.streamId,
           name: (_a = streamHeader.contentHeader.value.name) !== null && _a !== void 0 ? _a : 'unknown',
@@ -19459,7 +21022,8 @@ class IncomingDataStreamManager {
           size: streamHeader.totalLength ? Number(streamHeader.totalLength) : undefined,
           topic: streamHeader.topic,
           timestamp: bigIntToNumber(streamHeader.timestamp),
-          attributes: streamHeader.attributes
+          attributes: streamHeader.attributes,
+          encryptionType
         };
         const stream = new ReadableStream({
           start: controller => {
@@ -19487,13 +21051,17 @@ class IncomingDataStreamManager {
         }
         let streamController;
         const outOfBandFailureRejectingFuture = new Future();
+        outOfBandFailureRejectingFuture.promise.catch(err => {
+          this.log.error(err);
+        });
         const info = {
           id: streamHeader.streamId,
           mimeType: streamHeader.mimeType,
           size: streamHeader.totalLength ? Number(streamHeader.totalLength) : undefined,
           topic: streamHeader.topic,
           timestamp: Number(streamHeader.timestamp),
-          attributes: streamHeader.attributes
+          attributes: streamHeader.attributes,
+          encryptionType
         };
         const stream = new ReadableStream({
           start: controller => {
@@ -19516,34 +21084,46 @@ class IncomingDataStreamManager {
       }
     });
   }
-  handleStreamChunk(chunk) {
+  handleStreamChunk(chunk, encryptionType) {
     const fileBuffer = this.byteStreamControllers.get(chunk.streamId);
     if (fileBuffer) {
-      if (chunk.content.length > 0) {
+      if (fileBuffer.info.encryptionType !== encryptionType) {
+        fileBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(chunk.streamId, ". Expected ").concat(encryptionType, ", got ").concat(fileBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
+        this.byteStreamControllers.delete(chunk.streamId);
+      } else if (chunk.content.length > 0) {
         fileBuffer.controller.enqueue(chunk);
       }
     }
     const textBuffer = this.textStreamControllers.get(chunk.streamId);
     if (textBuffer) {
-      if (chunk.content.length > 0) {
+      if (textBuffer.info.encryptionType !== encryptionType) {
+        textBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(chunk.streamId, ". Expected ").concat(encryptionType, ", got ").concat(textBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
+        this.textStreamControllers.delete(chunk.streamId);
+      } else if (chunk.content.length > 0) {
         textBuffer.controller.enqueue(chunk);
       }
     }
   }
-  handleStreamTrailer(trailer) {
+  handleStreamTrailer(trailer, encryptionType) {
     const textBuffer = this.textStreamControllers.get(trailer.streamId);
     if (textBuffer) {
-      textBuffer.info.attributes = Object.assign(Object.assign({}, textBuffer.info.attributes), trailer.attributes);
-      textBuffer.controller.close();
-      this.textStreamControllers.delete(trailer.streamId);
+      if (textBuffer.info.encryptionType !== encryptionType) {
+        textBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(trailer.streamId, ". Expected ").concat(encryptionType, ", got ").concat(textBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
+      } else {
+        textBuffer.info.attributes = Object.assign(Object.assign({}, textBuffer.info.attributes), trailer.attributes);
+        textBuffer.controller.close();
+        this.textStreamControllers.delete(trailer.streamId);
+      }
     }
     const fileBuffer = this.byteStreamControllers.get(trailer.streamId);
     if (fileBuffer) {
-      {
+      if (fileBuffer.info.encryptionType !== encryptionType) {
+        fileBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(trailer.streamId, ". Expected ").concat(encryptionType, ", got ").concat(fileBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
+      } else {
         fileBuffer.info.attributes = Object.assign(Object.assign({}, fileBuffer.info.attributes), trailer.attributes);
         fileBuffer.controller.close();
-        this.byteStreamControllers.delete(trailer.streamId);
       }
+      this.byteStreamControllers.delete(trailer.streamId);
     }
   }
 }
@@ -19630,7 +21210,7 @@ class OutgoingDataStreamManager {
    */
   streamText(options) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b;
+      var _a, _b, _c;
       const streamId = (_a = options === null || options === void 0 ? void 0 : options.streamId) !== null && _a !== void 0 ? _a : crypto.randomUUID();
       const info = {
         id: streamId,
@@ -19638,7 +21218,8 @@ class OutgoingDataStreamManager {
         timestamp: Date.now(),
         topic: (_b = options === null || options === void 0 ? void 0 : options.topic) !== null && _b !== void 0 ? _b : '',
         size: options === null || options === void 0 ? void 0 : options.totalSize,
-        attributes: options === null || options === void 0 ? void 0 : options.attributes
+        attributes: options === null || options === void 0 ? void 0 : options.attributes,
+        encryptionType: ((_c = this.engine.e2eeManager) === null || _c === void 0 ? void 0 : _c.isDataChannelEncryptionEnabled) ? Encryption_Type.GCM : Encryption_Type.NONE
       };
       const header = new DataStream_Header({
         streamId,
@@ -19756,7 +21337,7 @@ class OutgoingDataStreamManager {
   }
   streamBytes(options) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b, _c, _d, _e;
+      var _a, _b, _c, _d, _e, _f;
       const streamId = (_a = options === null || options === void 0 ? void 0 : options.streamId) !== null && _a !== void 0 ? _a : crypto.randomUUID();
       const destinationIdentities = options === null || options === void 0 ? void 0 : options.destinationIdentities;
       const info = {
@@ -19766,10 +21347,11 @@ class OutgoingDataStreamManager {
         timestamp: Date.now(),
         attributes: options === null || options === void 0 ? void 0 : options.attributes,
         size: options === null || options === void 0 ? void 0 : options.totalSize,
-        name: (_d = options === null || options === void 0 ? void 0 : options.name) !== null && _d !== void 0 ? _d : 'unknown'
+        name: (_d = options === null || options === void 0 ? void 0 : options.name) !== null && _d !== void 0 ? _d : 'unknown',
+        encryptionType: ((_e = this.engine.e2eeManager) === null || _e === void 0 ? void 0 : _e.isDataChannelEncryptionEnabled) ? Encryption_Type.GCM : Encryption_Type.NONE
       };
       const header = new DataStream_Header({
-        totalLength: numberToBigInt((_e = info.size) !== null && _e !== void 0 ? _e : 0),
+        totalLength: numberToBigInt((_f = info.size) !== null && _f !== void 0 ? _f : 0),
         mimeType: info.mimeType,
         streamId,
         topic: info.topic,
@@ -22523,16 +24105,17 @@ class LocalParticipant extends Participant {
         const kind = options.reliable ? DataPacket_Kind.RELIABLE : DataPacket_Kind.LOSSY;
         const destinationIdentities = options.destinationIdentities;
         const topic = options.topic;
+        let userPacket = new UserPacket({
+          participantIdentity: _this4.identity,
+          payload: data,
+          destinationIdentities,
+          topic
+        });
         const packet = new DataPacket({
           kind: kind,
           value: {
             case: 'user',
-            value: new UserPacket({
-              participantIdentity: _this4.identity,
-              payload: data,
-              destinationIdentities,
-              topic
-            })
+            value: userPacket
           }
         });
         yield _this4.engine.sendDataPacket(packet, kind);
@@ -23457,6 +25040,9 @@ const connectionReconcileFrequency = 4 * 1000;
  * @noInheritDoc
  */
 class Room extends eventsExports.EventEmitter {
+  get hasE2EESetup() {
+    return this.e2eeManager !== undefined;
+  }
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -23584,7 +25170,8 @@ class Room extends eventsExports.EventEmitter {
         adaptiveStream: typeof roomOptions.adaptiveStream === 'object' ? true : roomOptions.adaptiveStream,
         maxRetries: connectOptions.maxRetries,
         e2eeEnabled: !!this.e2eeManager,
-        websocketTimeout: connectOptions.websocketTimeout
+        websocketTimeout: connectOptions.websocketTimeout,
+        singlePeerConnection: roomOptions.singlePeerConnection
       }, abortController.signal);
       let serverInfo = joinResponse.serverInfo;
       if (!serverInfo) {
@@ -23617,7 +25204,7 @@ class Room extends eventsExports.EventEmitter {
       this.localParticipant.sid = pi.sid;
       this.localParticipant.identity = pi.identity;
       this.localParticipant.setEnabledPublishCodecs(joinResponse.enabledPublishCodecs);
-      if (this.options.e2ee && this.e2eeManager) {
+      if (this.e2eeManager) {
         try {
           this.e2eeManager.setSifTrailer(joinResponse.sifTrailer);
         } catch (e) {
@@ -23721,8 +25308,9 @@ class Room extends eventsExports.EventEmitter {
             _this2.log.info('disconnect from room', Object.assign({}, _this2.logContext));
             if (_this2.state === ConnectionState.Connecting || _this2.state === ConnectionState.Reconnecting || _this2.isResuming) {
               // try aborting pending connection attempt
-              _this2.log.warn('abort connection attempt', _this2.logContext);
-              (_a = _this2.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+              const msg = 'Abort connection attempt due to user initiated disconnect';
+              _this2.log.warn(msg, _this2.logContext);
+              (_a = _this2.abortController) === null || _a === void 0 ? void 0 : _a.abort(msg);
               // in case the abort controller didn't manage to cancel the connection attempt, reject the connect promise explicitly
               (_c = (_b = _this2.connectFuture) === null || _b === void 0 ? void 0 : _b.reject) === null || _c === void 0 ? void 0 : _c.call(_b, new ConnectionError('Client initiated disconnect', ConnectionErrorReason.Cancelled));
               _this2.connectFuture = undefined;
@@ -24005,11 +25593,11 @@ class Room extends eventsExports.EventEmitter {
       }
       pub.setSubscriptionError(update.err);
     };
-    this.handleDataPacket = packet => {
+    this.handleDataPacket = (packet, encryptionType) => {
       // find the participant
       const participant = this.remoteParticipants.get(packet.participantIdentity);
       if (packet.value.case === 'user') {
-        this.handleUserPacket(participant, packet.value.value, packet.kind);
+        this.handleUserPacket(participant, packet.value.value, packet.kind, encryptionType);
       } else if (packet.value.case === 'transcription') {
         this.handleTranscription(participant, packet.value.value);
       } else if (packet.value.case === 'sipDtmf') {
@@ -24019,16 +25607,16 @@ class Room extends eventsExports.EventEmitter {
       } else if (packet.value.case === 'metrics') {
         this.handleMetrics(packet.value.value, participant);
       } else if (packet.value.case === 'streamHeader' || packet.value.case === 'streamChunk' || packet.value.case === 'streamTrailer') {
-        this.handleDataStream(packet);
+        this.handleDataStream(packet, encryptionType);
       } else if (packet.value.case === 'rpcRequest') {
         const rpc = packet.value.value;
         this.handleIncomingRpcRequest(packet.participantIdentity, rpc.id, rpc.method, rpc.payload, rpc.responseTimeoutMs, rpc.version);
       }
     };
-    this.handleUserPacket = (participant, userPacket, kind) => {
-      this.emit(RoomEvent.DataReceived, userPacket.payload, participant, kind, userPacket.topic);
+    this.handleUserPacket = (participant, userPacket, kind, encryptionType) => {
+      this.emit(RoomEvent.DataReceived, userPacket.payload, participant, kind, userPacket.topic, encryptionType);
       // also emit on the participant
-      participant === null || participant === void 0 ? void 0 : participant.emit(ParticipantEvent.DataReceived, userPacket.payload, kind);
+      participant === null || participant === void 0 ? void 0 : participant.emit(ParticipantEvent.DataReceived, userPacket.payload, kind, encryptionType);
     };
     this.handleSipDtmf = (participant, dtmf) => {
       this.emit(RoomEvent.SipDTMFReceived, dtmf, participant);
@@ -24051,8 +25639,8 @@ class Room extends eventsExports.EventEmitter {
     this.handleMetrics = (metrics, participant) => {
       this.emit(RoomEvent.MetricsReceived, metrics, participant);
     };
-    this.handleDataStream = packet => {
-      this.incomingDataStreamManager.handleDataStreamPacket(packet);
+    this.handleDataStream = (packet, encryptionType) => {
+      this.incomingDataStreamManager.handleDataStreamPacket(packet, encryptionType);
     };
     this.bufferedSegments = new Map();
     this.handleAudioPlaybackStarted = () => {
@@ -24193,6 +25781,10 @@ class Room extends eventsExports.EventEmitter {
     this.outgoingDataStreamManager = new OutgoingDataStreamManager(this.engine, this.log);
     this.disconnectLock = new _();
     this.localParticipant = new LocalParticipant('', '', this.engine, this.options, this.rpcHandlers, this.outgoingDataStreamManager);
+    if (this.options.e2ee || this.options.encryption) {
+      this.setupE2EE();
+    }
+    this.engine.e2eeManager = this.e2eeManager;
     if (this.options.videoCaptureDefaults.deviceId) {
       this.localParticipant.activeDeviceMap.set('videoinput', unwrapConstraint(this.options.videoCaptureDefaults.deviceId));
     }
@@ -24202,9 +25794,6 @@ class Room extends eventsExports.EventEmitter {
     if ((_b = this.options.audioOutput) === null || _b === void 0 ? void 0 : _b.deviceId) {
       this.switchActiveDevice('audiooutput', unwrapConstraint(this.options.audioOutput.deviceId)).catch(e => this.log.warn("Could not set audio output: ".concat(e.message), this.logContext));
     }
-    if (this.options.e2ee) {
-      this.setupE2EE();
-    }
     if (isWeb()) {
       const abortController = new AbortController();
       // in order to catch device changes prior to room connection we need to register the event in the constructor
@@ -24286,12 +25875,16 @@ class Room extends eventsExports.EventEmitter {
     });
   }
   setupE2EE() {
+    // when encryption is enabled via `options.encryption`, we enable data channel encryption
     var _a;
-    if (this.options.e2ee) {
-      if ('e2eeManager' in this.options.e2ee) {
-        this.e2eeManager = this.options.e2ee.e2eeManager;
+    const dcEncryptionEnabled = !!this.options.encryption;
+    const e2eeOptions = this.options.encryption || this.options.e2ee;
+    if (e2eeOptions) {
+      if ('e2eeManager' in e2eeOptions) {
+        this.e2eeManager = e2eeOptions.e2eeManager;
+        this.e2eeManager.isDataChannelEncryptionEnabled = dcEncryptionEnabled;
       } else {
-        this.e2eeManager = new E2EEManager(this.options.e2ee);
+        this.e2eeManager = new E2EEManager(e2eeOptions, dcEncryptionEnabled);
       }
       this.e2eeManager.on(EncryptionEvent.ParticipantEncryptionStatusChanged, (enabled, participant) => {
         if (isLocalParticipant(participant)) {
@@ -24369,6 +25962,7 @@ class Room extends eventsExports.EventEmitter {
       return;
     }
     this.engine = new RTCEngine(this.options);
+    this.engine.e2eeManager = this.e2eeManager;
     this.engine.on(EngineEvent.ParticipantUpdate, this.handleParticipantUpdates).on(EngineEvent.RoomUpdate, this.handleRoomUpdate).on(EngineEvent.SpeakersChanged, this.handleSpeakersChanged).on(EngineEvent.StreamStateChanged, this.handleStreamStateUpdate).on(EngineEvent.ConnectionQualityUpdate, this.handleConnectionQualityUpdate).on(EngineEvent.SubscriptionError, this.handleSubscriptionError).on(EngineEvent.SubscriptionPermissionUpdate, this.handleSubscriptionPermissionUpdate).on(EngineEvent.MediaTrackAdded, (mediaTrack, stream, receiver) => {
       this.onTrackAdded(mediaTrack, stream, receiver);
     }).on(EngineEvent.Disconnected, reason => {
@@ -25769,6 +27363,11 @@ class PublishVideoCheck extends Checker {
       const video = document.createElement('video');
       video.srcObject = stream;
       video.muted = true;
+      video.autoplay = true;
+      video.playsInline = true;
+      // For iOS Safari
+      video.setAttribute('playsinline', 'true');
+      document.body.appendChild(video);
       yield new Promise(resolve => {
         video.onplay = () => {
           setTimeout(() => {
@@ -25858,7 +27457,8 @@ class TURNCheck extends Checker {
         autoSubscribe: true,
         maxRetries: 0,
         e2eeEnabled: false,
-        websocketTimeout: 15000
+        websocketTimeout: 15000,
+        singlePeerConnection: false
       });
       let hasTLS = false;
       let hasTURN = false;
@@ -25908,6 +27508,7 @@ class WebRTCCheck extends Checker {
       let hasTcp = false;
       let hasIpv4Udp = false;
       this.room.on(RoomEvent.SignalConnected, () => {
+        var _a;
         const prevTrickle = this.room.engine.client.onTrickle;
         this.room.engine.client.onTrickle = (sd, target) => {
           if (sd.candidate) {
@@ -25931,7 +27532,7 @@ class WebRTCCheck extends Checker {
             prevTrickle(sd, target);
           }
         };
-        if (this.room.engine.pcManager) {
+        if ((_a = this.room.engine.pcManager) === null || _a === void 0 ? void 0 : _a.subscriber) {
           this.room.engine.pcManager.subscriber.onIceCandidateError = ev => {
             if (ev instanceof RTCPeerConnectionIceErrorEvent) {
               this.appendWarning("error with ICE candidate: ".concat(ev.errorCode, " ").concat(ev.errorText, " ").concat(ev.url));
@@ -25987,7 +27588,8 @@ class WebSocketCheck extends Checker {
         autoSubscribe: true,
         maxRetries: 0,
         e2eeEnabled: false,
-        websocketTimeout: 15000
+        websocketTimeout: 15000,
+        singlePeerConnection: false
       });
       this.appendMessage("Connected to server, version ".concat(joinRes.serverVersion, "."));
       if (((_a = joinRes.serverInfo) === null || _a === void 0 ? void 0 : _a.edition) === ServerInfo_Edition.Cloud && ((_b = joinRes.serverInfo) === null || _b === void 0 ? void 0 : _b.region)) {
@@ -26088,6 +27690,523 @@ class ConnectionCheck extends eventsExports.EventEmitter {
   }
 }
 
+/** A Fixed TokenSource is a token source that takes no parameters and returns a completely
+ * independently derived value on each fetch() call.
+ *
+ * The most common downstream implementer is {@link TokenSourceLiteral}.
+ */
+class TokenSourceFixed {}
+/** A Configurable TokenSource is a token source that takes a
+ * {@link TokenSourceFetchOptions} object as input and returns a deterministic
+ * {@link TokenSourceResponseObject} output based on the options specified.
+ *
+ * For example, if options.participantName is set, it should be expected that
+ * all tokens that are generated will have participant name field set to the
+ * provided value.
+ *
+ * A few common downstream implementers are {@link TokenSourceEndpoint}
+ * and {@link TokenSourceCustom}.
+ */
+class TokenSourceConfigurable {}
+
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+new TextEncoder();
+const decoder = new TextDecoder();
+
+function decodeBase64(encoded) {
+  if (Uint8Array.fromBase64) {
+    return Uint8Array.fromBase64(encoded);
+  }
+  const binary = atob(encoded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+function decode(input) {
+  if (Uint8Array.fromBase64) {
+    return Uint8Array.fromBase64(typeof input === 'string' ? input : decoder.decode(input), {
+      alphabet: 'base64url'
+    });
+  }
+  let encoded = input;
+  if (encoded instanceof Uint8Array) {
+    encoded = decoder.decode(encoded);
+  }
+  encoded = encoded.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, '');
+  try {
+    return decodeBase64(encoded);
+  } catch (_unused) {
+    throw new TypeError('The input to be decoded is not correctly encoded.');
+  }
+}
+
+class JOSEError extends Error {
+  constructor(message, options) {
+    var _Error$captureStackTr;
+    super(message, options);
+    _defineProperty(this, "code", 'ERR_JOSE_GENERIC');
+    this.name = this.constructor.name;
+    (_Error$captureStackTr = Error.captureStackTrace) === null || _Error$captureStackTr === void 0 || _Error$captureStackTr.call(Error, this, this.constructor);
+  }
+}
+_defineProperty(JOSEError, "code", 'ERR_JOSE_GENERIC');
+class JWTClaimValidationFailed extends JOSEError {
+  constructor(message, payload) {
+    let claim = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'unspecified';
+    let reason = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'unspecified';
+    super(message, {
+      cause: {
+        claim,
+        reason,
+        payload
+      }
+    });
+    _defineProperty(this, "code", 'ERR_JWT_CLAIM_VALIDATION_FAILED');
+    _defineProperty(this, "claim", void 0);
+    _defineProperty(this, "reason", void 0);
+    _defineProperty(this, "payload", void 0);
+    this.claim = claim;
+    this.reason = reason;
+    this.payload = payload;
+  }
+}
+_defineProperty(JWTClaimValidationFailed, "code", 'ERR_JWT_CLAIM_VALIDATION_FAILED');
+class JWTExpired extends JOSEError {
+  constructor(message, payload) {
+    let claim = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'unspecified';
+    let reason = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'unspecified';
+    super(message, {
+      cause: {
+        claim,
+        reason,
+        payload
+      }
+    });
+    _defineProperty(this, "code", 'ERR_JWT_EXPIRED');
+    _defineProperty(this, "claim", void 0);
+    _defineProperty(this, "reason", void 0);
+    _defineProperty(this, "payload", void 0);
+    this.claim = claim;
+    this.reason = reason;
+    this.payload = payload;
+  }
+}
+_defineProperty(JWTExpired, "code", 'ERR_JWT_EXPIRED');
+class JOSEAlgNotAllowed extends JOSEError {
+  constructor() {
+    super(...arguments);
+    _defineProperty(this, "code", 'ERR_JOSE_ALG_NOT_ALLOWED');
+  }
+}
+_defineProperty(JOSEAlgNotAllowed, "code", 'ERR_JOSE_ALG_NOT_ALLOWED');
+class JOSENotSupported extends JOSEError {
+  constructor() {
+    super(...arguments);
+    _defineProperty(this, "code", 'ERR_JOSE_NOT_SUPPORTED');
+  }
+}
+_defineProperty(JOSENotSupported, "code", 'ERR_JOSE_NOT_SUPPORTED');
+class JWEDecryptionFailed extends JOSEError {
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'decryption operation failed';
+    let options = arguments.length > 1 ? arguments[1] : undefined;
+    super(message, options);
+    _defineProperty(this, "code", 'ERR_JWE_DECRYPTION_FAILED');
+  }
+}
+_defineProperty(JWEDecryptionFailed, "code", 'ERR_JWE_DECRYPTION_FAILED');
+class JWEInvalid extends JOSEError {
+  constructor() {
+    super(...arguments);
+    _defineProperty(this, "code", 'ERR_JWE_INVALID');
+  }
+}
+_defineProperty(JWEInvalid, "code", 'ERR_JWE_INVALID');
+class JWSInvalid extends JOSEError {
+  constructor() {
+    super(...arguments);
+    _defineProperty(this, "code", 'ERR_JWS_INVALID');
+  }
+}
+_defineProperty(JWSInvalid, "code", 'ERR_JWS_INVALID');
+class JWTInvalid extends JOSEError {
+  constructor() {
+    super(...arguments);
+    _defineProperty(this, "code", 'ERR_JWT_INVALID');
+  }
+}
+_defineProperty(JWTInvalid, "code", 'ERR_JWT_INVALID');
+class JWKInvalid extends JOSEError {
+  constructor() {
+    super(...arguments);
+    _defineProperty(this, "code", 'ERR_JWK_INVALID');
+  }
+}
+_defineProperty(JWKInvalid, "code", 'ERR_JWK_INVALID');
+class JWKSInvalid extends JOSEError {
+  constructor() {
+    super(...arguments);
+    _defineProperty(this, "code", 'ERR_JWKS_INVALID');
+  }
+}
+_defineProperty(JWKSInvalid, "code", 'ERR_JWKS_INVALID');
+class JWKSNoMatchingKey extends JOSEError {
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'no applicable key found in the JSON Web Key Set';
+    let options = arguments.length > 1 ? arguments[1] : undefined;
+    super(message, options);
+    _defineProperty(this, "code", 'ERR_JWKS_NO_MATCHING_KEY');
+  }
+}
+_defineProperty(JWKSNoMatchingKey, "code", 'ERR_JWKS_NO_MATCHING_KEY');
+class JWKSMultipleMatchingKeys extends JOSEError {
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'multiple matching keys found in the JSON Web Key Set';
+    let options = arguments.length > 1 ? arguments[1] : undefined;
+    super(message, options);
+    _defineProperty(this, Symbol.asyncIterator, void 0);
+    _defineProperty(this, "code", 'ERR_JWKS_MULTIPLE_MATCHING_KEYS');
+  }
+}
+_defineProperty(JWKSMultipleMatchingKeys, "code", 'ERR_JWKS_MULTIPLE_MATCHING_KEYS');
+class JWKSTimeout extends JOSEError {
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'request timed out';
+    let options = arguments.length > 1 ? arguments[1] : undefined;
+    super(message, options);
+    _defineProperty(this, "code", 'ERR_JWKS_TIMEOUT');
+  }
+}
+_defineProperty(JWKSTimeout, "code", 'ERR_JWKS_TIMEOUT');
+class JWSSignatureVerificationFailed extends JOSEError {
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'signature verification failed';
+    let options = arguments.length > 1 ? arguments[1] : undefined;
+    super(message, options);
+    _defineProperty(this, "code", 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED');
+  }
+}
+_defineProperty(JWSSignatureVerificationFailed, "code", 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED');
+
+function isObjectLike(value) {
+  return typeof value === 'object' && value !== null;
+}
+var isObject = input => {
+  if (!isObjectLike(input) || Object.prototype.toString.call(input) !== '[object Object]') {
+    return false;
+  }
+  if (Object.getPrototypeOf(input) === null) {
+    return true;
+  }
+  let proto = input;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(input) === proto;
+};
+
+function decodeJwt(jwt) {
+  if (typeof jwt !== 'string') throw new JWTInvalid('JWTs must use Compact JWS serialization, JWT must be a string');
+  const {
+    1: payload,
+    length
+  } = jwt.split('.');
+  if (length === 5) throw new JWTInvalid('Only JWTs using Compact JWS serialization can be decoded');
+  if (length !== 3) throw new JWTInvalid('Invalid JWT');
+  if (!payload) throw new JWTInvalid('JWTs must contain a payload');
+  let decoded;
+  try {
+    decoded = decode(payload);
+  } catch (_unused) {
+    throw new JWTInvalid('Failed to base64url decode the payload');
+  }
+  let result;
+  try {
+    result = JSON.parse(decoder.decode(decoded));
+  } catch (_unused2) {
+    throw new JWTInvalid('Failed to parse the decoded payload as JSON');
+  }
+  if (!isObject(result)) throw new JWTInvalid('Invalid JWT Claims Set');
+  return result;
+}
+
+const ONE_SECOND_IN_MILLISECONDS = 1000;
+const ONE_MINUTE_IN_MILLISECONDS = 60 * ONE_SECOND_IN_MILLISECONDS;
+function isResponseTokenValid(response) {
+  const jwtPayload = decodeTokenPayload(response.participantToken);
+  if (!(jwtPayload === null || jwtPayload === void 0 ? void 0 : jwtPayload.nbf) || !(jwtPayload === null || jwtPayload === void 0 ? void 0 : jwtPayload.exp)) {
+    return true;
+  }
+  const now = new Date();
+  const nbfInMilliseconds = jwtPayload.nbf * ONE_SECOND_IN_MILLISECONDS;
+  const nbfDate = new Date(nbfInMilliseconds);
+  const expInMilliseconds = jwtPayload.exp * ONE_SECOND_IN_MILLISECONDS;
+  const expDate = new Date(expInMilliseconds - ONE_MINUTE_IN_MILLISECONDS);
+  return nbfDate <= now && expDate > now;
+}
+function decodeTokenPayload(token) {
+  const payload = decodeJwt(token);
+  const {
+      roomConfig
+    } = payload,
+    rest = __rest(payload, ["roomConfig"]);
+  const mappedPayload = Object.assign(Object.assign({}, rest), {
+    roomConfig: payload.roomConfig ? RoomConfiguration.fromJson(payload.roomConfig) : undefined
+  });
+  return mappedPayload;
+}
+
+/** A TokenSourceCached is a TokenSource which caches the last {@link TokenSourceResponseObject} value and returns it
+ * until a) it expires or b) the {@link TokenSourceFetchOptions} provided to .fetch(...) change. */
+class TokenSourceCached extends TokenSourceConfigurable {
+  constructor() {
+    super(...arguments);
+    this.cachedFetchOptions = null;
+    this.cachedResponse = null;
+    this.fetchMutex = new _();
+  }
+  isSameAsCachedFetchOptions(options) {
+    if (!this.cachedFetchOptions) {
+      return false;
+    }
+    for (const key of Object.keys(this.cachedFetchOptions)) {
+      switch (key) {
+        case 'roomName':
+        case 'participantName':
+        case 'participantIdentity':
+        case 'participantMetadata':
+        case 'participantAttributes':
+        case 'agentName':
+        case 'agentMetadata':
+          if (this.cachedFetchOptions[key] !== options[key]) {
+            return false;
+          }
+          break;
+        default:
+          // ref: https://stackoverflow.com/a/58009992
+          const exhaustiveCheckedKey = key;
+          throw new Error("Options key ".concat(exhaustiveCheckedKey, " not being checked for equality!"));
+      }
+    }
+    return true;
+  }
+  shouldReturnCachedValueFromFetch(fetchOptions) {
+    if (!this.cachedResponse) {
+      return false;
+    }
+    if (!isResponseTokenValid(this.cachedResponse)) {
+      return false;
+    }
+    if (this.isSameAsCachedFetchOptions(fetchOptions)) {
+      return false;
+    }
+    return true;
+  }
+  getCachedResponseJwtPayload() {
+    if (!this.cachedResponse) {
+      return null;
+    }
+    return decodeTokenPayload(this.cachedResponse.participantToken);
+  }
+  fetch(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.fetchMutex.lock();
+      try {
+        if (this.shouldReturnCachedValueFromFetch(options)) {
+          return this.cachedResponse.toJson();
+        }
+        this.cachedFetchOptions = options;
+        const tokenResponse = yield this.update(options);
+        this.cachedResponse = tokenResponse;
+        return tokenResponse.toJson();
+      } finally {
+        unlock();
+      }
+    });
+  }
+}
+class TokenSourceLiteral extends TokenSourceFixed {
+  constructor(literalOrFn) {
+    super();
+    this.literalOrFn = literalOrFn;
+  }
+  fetch() {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (typeof this.literalOrFn === 'function') {
+        return this.literalOrFn();
+      } else {
+        return this.literalOrFn;
+      }
+    });
+  }
+}
+class TokenSourceCustom extends TokenSourceCached {
+  constructor(customFn) {
+    super();
+    this.customFn = customFn;
+  }
+  update(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const resultMaybePromise = this.customFn(options);
+      let result;
+      if (resultMaybePromise instanceof Promise) {
+        result = yield resultMaybePromise;
+      } else {
+        result = resultMaybePromise;
+      }
+      return TokenSourceResponse.fromJson(result, {
+        // NOTE: it could be possible that the response body could contain more fields than just
+        // what's in TokenSourceResponse depending on the implementation
+        ignoreUnknownFields: true
+      });
+    });
+  }
+}
+class TokenSourceEndpoint extends TokenSourceCached {
+  constructor(url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super();
+    this.url = url;
+    this.endpointOptions = options;
+  }
+  createRequestFromOptions(options) {
+    var _a, _b, _c;
+    const request = new TokenSourceRequest();
+    for (const key of Object.keys(options)) {
+      switch (key) {
+        case 'roomName':
+        case 'participantName':
+        case 'participantIdentity':
+        case 'participantMetadata':
+          request[key] = options[key];
+          break;
+        case 'participantAttributes':
+          request.participantAttributes = (_a = options.participantAttributes) !== null && _a !== void 0 ? _a : {};
+          break;
+        case 'agentName':
+          request.roomConfig = (_b = request.roomConfig) !== null && _b !== void 0 ? _b : new RoomConfiguration();
+          if (request.roomConfig.agents.length === 0) {
+            request.roomConfig.agents.push(new RoomAgentDispatch());
+          }
+          request.roomConfig.agents[0].agentName = options.agentName;
+          break;
+        case 'agentMetadata':
+          request.roomConfig = (_c = request.roomConfig) !== null && _c !== void 0 ? _c : new RoomConfiguration();
+          if (request.roomConfig.agents.length === 0) {
+            request.roomConfig.agents.push(new RoomAgentDispatch());
+          }
+          request.roomConfig.agents[0].metadata = options.agentMetadata;
+          break;
+        default:
+          // ref: https://stackoverflow.com/a/58009992
+          const exhaustiveCheckedKey = key;
+          throw new Error("Options key ".concat(exhaustiveCheckedKey, " not being included in forming request!"));
+      }
+    }
+    return request;
+  }
+  update(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      const request = this.createRequestFromOptions(options);
+      const response = yield fetch(this.url, Object.assign(Object.assign({}, this.endpointOptions), {
+        method: (_a = this.endpointOptions.method) !== null && _a !== void 0 ? _a : 'POST',
+        headers: Object.assign({
+          'Content-Type': 'application/json'
+        }, this.endpointOptions.headers),
+        body: request.toJsonString({
+          useProtoFieldName: true
+        })
+      }));
+      if (!response.ok) {
+        throw new Error("Error generating token from endpoint ".concat(this.url, ": received ").concat(response.status, " / ").concat(yield response.text()));
+      }
+      const body = yield response.json();
+      return TokenSourceResponse.fromJson(body, {
+        // NOTE: it could be possible that the response body could contain more fields than just
+        // what's in TokenSourceResponse depending on the implementation (ie, SandboxTokenServer)
+        ignoreUnknownFields: true
+      });
+    });
+  }
+}
+class TokenSourceSandboxTokenServer extends TokenSourceEndpoint {
+  constructor(sandboxId, options) {
+    const {
+        baseUrl = 'https://cloud-api.livekit.io'
+      } = options,
+      rest = __rest(options, ["baseUrl"]);
+    super("".concat(baseUrl, "/api/v2/sandbox/connection-details"), Object.assign(Object.assign({}, rest), {
+      headers: {
+        'X-Sandbox-ID': sandboxId
+      }
+    }));
+  }
+}
+const TokenSource = {
+  /** TokenSource.literal contains a single, literal set of {@link TokenSourceResponseObject}
+   * credentials, either provided directly or returned from a provided function. */
+  literal(literalOrFn) {
+    return new TokenSourceLiteral(literalOrFn);
+  },
+  /**
+   * TokenSource.custom allows a user to define a manual function which generates new
+   * {@link TokenSourceResponseObject} values on demand.
+   *
+   * Use this to get credentials from custom backends / etc.
+   */
+  custom(customFn) {
+    return new TokenSourceCustom(customFn);
+  },
+  /**
+   * TokenSource.endpoint creates a token source that fetches credentials from a given URL using
+   * the standard endpoint format:
+   * FIXME: add docs link here in the future!
+   */
+  endpoint(url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return new TokenSourceEndpoint(url, options);
+  },
+  /**
+   * TokenSource.sandboxTokenServer queries a sandbox token server for credentials,
+   * which supports quick prototyping / getting started types of use cases.
+   *
+   * This token provider is INSECURE and should NOT be used in production.
+   *
+   * For more info:
+   * @see https://cloud.livekit.io/projects/p_/sandbox/templates/token-server
+   */
+  sandboxTokenServer(sandboxId) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return new TokenSourceSandboxTokenServer(sandboxId, options);
+  }
+};
+
 /**
  * Try to analyze the local track to determine the facing mode of a track.
  *
@@ -26169,5 +28288,5 @@ function isFacingModeValue(item) {
   return item === undefined || allowedValues.includes(item);
 }
 
-export { AudioPresets, BackupCodecPolicy, BaseKeyProvider, CheckStatus, Checker, ConnectionCheck, ConnectionError, ConnectionErrorReason, ConnectionQuality, ConnectionState, CriticalTimers, CryptorError, CryptorErrorReason, CryptorEvent, DataPacket_Kind, DataStreamError, DataStreamErrorReason, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalTrackRecorder, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, _ as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, PublishTrackError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RpcError, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, TrackType, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, attributeTypings as attributes, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isAudioTrack, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isScriptTransformSupported, isVideoFrame, isVideoTrack, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
+export { AudioPresets, BackupCodecPolicy, BaseKeyProvider, CheckStatus, Checker, ConnectionCheck, ConnectionError, ConnectionErrorReason, ConnectionQuality, ConnectionState, CriticalTimers, CryptorError, CryptorErrorReason, CryptorEvent, DataPacket_Kind, DataStreamError, DataStreamErrorReason, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, Encryption_Type, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalTrackRecorder, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, _ as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, PublishTrackError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RpcError, ScreenSharePresets, SignalRequestError, SubscriptionError, TokenSource, TokenSourceConfigurable, TokenSourceCustom, TokenSourceEndpoint, TokenSourceFixed, TokenSourceLiteral, TokenSourceSandboxTokenServer, Track, TrackEvent, TrackInvalidError, TrackPublication, TrackType, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, asEncryptablePacket, attachToElement, attributeTypings as attributes, audioCodecs, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isAudioCodec, isAudioTrack, isBackupCodec, isBackupVideoCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isScriptTransformSupported, isVideoCodec, isVideoFrame, isVideoTrack, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsAudioOutputSelection, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
 //# sourceMappingURL=livekit-client.esm.mjs.map