@livekit/rtc-node 0.13.4 → 0.13.6

package/package.json

@@ -3,7 +3,7 @@
   "description": "LiveKit RTC Node",
   "license": "Apache-2.0",
   "author": "LiveKit",
-  "version": "0.13.4",
+  "version": "0.13.6",
   "main": "dist/index.js",
   "require": "dist/index.cjs",
   "types": "dist/index.d.ts",
@@ -61,11 +61,11 @@
     "@bufbuild/protoc-gen-es": "^1.10.0"
   },
   "optionalDependencies": {
-    "@livekit/rtc-node-darwin-arm64": "0.13.4",
-    "@livekit/rtc-node-darwin-x64": "0.13.4",
-    "@livekit/rtc-node-linux-arm64-gnu": "0.13.4",
-    "@livekit/rtc-node-linux-x64-gnu": "0.13.4",
-    "@livekit/rtc-node-win32-x64-msvc": "0.13.4"
+    "@livekit/rtc-node-darwin-x64": "0.13.6",
+    "@livekit/rtc-node-linux-arm64-gnu": "0.13.6",
+    "@livekit/rtc-node-linux-x64-gnu": "0.13.6",
+    "@livekit/rtc-node-win32-x64-msvc": "0.13.6",
+    "@livekit/rtc-node-darwin-arm64": "0.13.6"
   },
   "engines": {
     "node": ">= 18"

package/src/data_streams/stream_reader.ts

@@ -5,7 +5,7 @@ import type { ReadableStream } from 'node:stream/web';
 import { log } from '../log.js';
 import type { DataStream_Chunk } from '../proto/room_pb.js';
 import { bigIntToNumber } from '../utils.js';
-import type { BaseStreamInfo, ByteStreamInfo, TextStreamChunk, TextStreamInfo } from './types.js';
+import type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from './types.js';
 
 abstract class BaseStreamReader<T extends BaseStreamInfo> {
   protected reader: ReadableStream<DataStream_Chunk>;
@@ -124,7 +124,7 @@ export class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
     const decoder = new TextDecoder();
 
     return {
-      next: async (): Promise<IteratorResult<TextStreamChunk>> => {
+      next: async (): Promise<IteratorResult<string>> => {
         try {
           const { done, value } = await reader.read();
           if (done) {
@@ -133,14 +133,7 @@ export class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
             this.handleChunkReceived(value);
             return {
               done: false,
-              value: {
-                index: bigIntToNumber(value.chunkIndex)!,
-                current: decoder.decode(value.content!),
-                collected: Array.from(this.receivedChunks.values())
-                  .sort((a, b) => bigIntToNumber(a.chunkIndex!) - bigIntToNumber(b.chunkIndex!))
-                  .map((chunk) => decoder.decode(chunk.content!))
-                  .join(''),
-              },
+              value: decoder.decode(value.content!),
             };
           }
         } catch (error) {
@@ -149,7 +142,7 @@ export class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
         }
       },
 
-      return(): IteratorResult<TextStreamChunk> {
+      return(): IteratorResult<string> {
         reader.releaseLock();
         return { done: true, value: undefined };
       },
@@ -157,10 +150,10 @@ export class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
   }
 
   async readAll(): Promise<string> {
-    let latestString: string = '';
-    for await (const { collected } of this) {
-      latestString = collected;
+    let finalString: string = '';
+    for await (const chunk of this) {
+      finalString += chunk;
     }
-    return latestString;
+    return finalString;
   }
 }

package/src/data_streams/stream_writer.ts

@@ -5,23 +5,23 @@ import type { WritableStream } from 'node:stream/web';
 import type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from './types.js';
 
 class BaseStreamWriter<T, InfoType extends BaseStreamInfo> {
-  protected writableStream: WritableStream<[T, number?]>;
+  protected writableStream: WritableStream<T>;
 
-  protected defaultWriter: WritableStreamDefaultWriter<[T, number?]>;
+  protected defaultWriter: WritableStreamDefaultWriter<T>;
 
   protected onClose?: () => void;
 
   readonly info: InfoType;
 
-  constructor(writableStream: WritableStream<[T, number?]>, info: InfoType, onClose?: () => void) {
+  constructor(writableStream: WritableStream<T>, info: InfoType, onClose?: () => void) {
     this.writableStream = writableStream;
     this.defaultWriter = writableStream.getWriter();
     this.onClose = onClose;
     this.info = info;
   }
 
-  write(chunk: T, chunkIndex?: number): Promise<void> {
-    return this.defaultWriter.write([chunk, chunkIndex]);
+  write(chunk: T): Promise<void> {
+    return this.defaultWriter.write(chunk);
   }
 
   async close() {

package/src/data_streams/types.ts

@@ -27,12 +27,6 @@ export type ByteStreamInfo = BaseStreamInfo & {
 
 export type TextStreamInfo = BaseStreamInfo;
 
-export type TextStreamChunk = {
-  index: number;
-  current: string;
-  collected: string;
-};
-
 export interface DataStreamOptions {
   topic?: string;
   destinationIdentities?: Array<string>;

package/src/index.ts

@@ -2,48 +2,48 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-export { Room, RoomEvent, ConnectError, type RoomOptions, type RtcConfiguration } from './room.js';
-export { Participant, RemoteParticipant, LocalParticipant } from './participant.js';
-export {
-  Track,
-  type LocalTrack,
-  type RemoteTrack,
-  type VideoTrack,
-  LocalAudioTrack,
-  LocalVideoTrack,
-  RemoteAudioTrack,
-  RemoteVideoTrack,
-  type AudioTrack,
-} from './track.js';
-export { VideoFrame } from './video_frame.js';
 export { AudioFrame, combineAudioFrames } from './audio_frame.js';
-export { AudioStream } from './audio_stream.js';
 export { AudioResampler, AudioResamplerQuality } from './audio_resampler.js';
-export { VideoStream, type VideoFrameEvent } from './video_stream.js';
 export { AudioSource } from './audio_source.js';
-export { VideoSource } from './video_source.js';
-export {
-  TrackPublication,
-  RemoteTrackPublication,
-  LocalTrackPublication,
-} from './track_publication.js';
-export type { Transcription, TranscriptionSegment } from './transcription.js';
-export { E2EEManager, KeyProvider, FrameCryptor } from './e2ee.js';
-export type { E2EEOptions, KeyProviderOptions } from './e2ee.js';
+export { AudioStream } from './audio_stream.js';
 export * from './data_streams/index.js';
+export { E2EEManager, FrameCryptor, KeyProvider } from './e2ee.js';
+export type { E2EEOptions, KeyProviderOptions } from './e2ee.js';
+export { dispose } from './ffi_client.js';
+export { LocalParticipant, Participant, RemoteParticipant } from './participant.js';
+export { EncryptionState, EncryptionType } from './proto/e2ee_pb.js';
+export { DisconnectReason, ParticipantKind } from './proto/participant_pb.js';
 export {
   ConnectionQuality,
+  ConnectionState,
+  ContinualGatheringPolicy,
+  DataPacketKind,
   IceServer,
   IceTransportType,
-  DataPacketKind,
-  ContinualGatheringPolicy,
   TrackPublishOptions,
-  ConnectionState,
 } from './proto/room_pb.js';
-export { RpcError, type RpcInvocationData, type PerformRpcParams } from './rpc.js';
-export { EncryptionType, EncryptionState } from './proto/e2ee_pb.js';
 export { StreamState, TrackKind, TrackSource } from './proto/track_pb.js';
-export { VideoBufferType, VideoRotation, VideoCodec } from './proto/video_frame_pb.js';
-export { ParticipantKind } from './proto/participant_pb.js';
-export { dispose } from './ffi_client.js';
+export { VideoBufferType, VideoCodec, VideoRotation } from './proto/video_frame_pb.js';
+export { ConnectError, Room, RoomEvent, type RoomOptions, type RtcConfiguration } from './room.js';
+export { RpcError, type PerformRpcParams, type RpcInvocationData } from './rpc.js';
+export {
+  LocalAudioTrack,
+  LocalVideoTrack,
+  RemoteAudioTrack,
+  RemoteVideoTrack,
+  Track,
+  type AudioTrack,
+  type LocalTrack,
+  type RemoteTrack,
+  type VideoTrack,
+} from './track.js';
+export {
+  LocalTrackPublication,
+  RemoteTrackPublication,
+  TrackPublication,
+} from './track_publication.js';
+export type { Transcription, TranscriptionSegment } from './transcription.js';
 export type { ChatMessage } from './types.js';
+export { VideoFrame } from './video_frame.js';
+export { VideoSource } from './video_source.js';
+export { VideoStream, type VideoFrameEvent } from './video_stream.js';

package/src/participant.ts

@@ -293,40 +293,29 @@ export class LocalParticipant extends Participant {
 
     await this.sendStreamHeader(headerReq);
 
-    let chunkId = 0;
+    let nextChunkId = 0;
     const localHandle = this.ffi_handle.handle;
     const sendTrailer = this.sendStreamTrailer;
     const sendChunk = this.sendStreamChunk;
 
-    const writableStream = new WritableStream<[string, number?]>({
+    const writableStream = new WritableStream<string>({
       // Implement the sink
-      write([textChunk, overrideChunkId]) {
-        const textInBytes = new TextEncoder().encode(textChunk);
-
-        if (textInBytes.byteLength > STREAM_CHUNK_SIZE) {
-          this.abort?.();
-          throw new Error('chunk size too large');
-        }
-
-        return new Promise(async (resolve) => {
+      async write(text) {
+        for (const textByteChunk of splitUtf8(text, STREAM_CHUNK_SIZE)) {
           const chunkRequest = new SendStreamChunkRequest({
             senderIdentity,
             localParticipantHandle: localHandle,
             destinationIdentities,
             chunk: new DataStream_Chunk({
-              content: textInBytes,
+              content: textByteChunk,
               streamId,
-              chunkIndex: numberToBigInt(overrideChunkId ?? chunkId),
+              chunkIndex: numberToBigInt(nextChunkId),
             }),
           });
 
           await sendChunk(chunkRequest);
-
-          if (!overrideChunkId) {
-            chunkId += 1;
-            resolve();
-          }
-        });
+          nextChunkId += 1;
+        }
       },
       async close() {
         const trailerReq = new SendStreamTrailerRequest({
@@ -360,10 +349,7 @@ export class LocalParticipant extends Participant {
     },
   ) {
     const writer = await this.streamText(options);
-
-    for (const chunk in splitUtf8(text, STREAM_CHUNK_SIZE)) {
-      await writer.write(chunk);
-    }
+    await writer.write(text);
     await writer.close();
     return writer.info;
   }
@@ -419,8 +405,8 @@ export class LocalParticipant extends Participant {
     const sendChunk = this.sendStreamChunk;
     const writeMutex = new Mutex();
 
-    const writableStream = new WritableStream<[Uint8Array, number?]>({
-      async write([chunk]) {
+    const writableStream = new WritableStream<Uint8Array>({
+      async write(chunk) {
         const unlock = await writeMutex.lock();
 
         let byteOffset = 0;

package/src/proto/ffi_pb.ts

@@ -20,7 +20,7 @@
 import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
 import { Message, proto2 } from "@bufbuild/protobuf";
 import { ConnectCallback, ConnectRequest, ConnectResponse, DisconnectCallback, DisconnectRequest, DisconnectResponse, EditChatMessageRequest, GetSessionStatsCallback, GetSessionStatsRequest, GetSessionStatsResponse, PublishDataCallback, PublishDataRequest, PublishDataResponse, PublishSipDtmfCallback, PublishSipDtmfRequest, PublishSipDtmfResponse, PublishTrackCallback, PublishTrackRequest, PublishTrackResponse, PublishTranscriptionCallback, PublishTranscriptionRequest, PublishTranscriptionResponse, RoomEvent, SendChatMessageCallback, SendChatMessageRequest, SendChatMessageResponse, SendStreamChunkCallback, SendStreamChunkRequest, SendStreamChunkResponse, SendStreamHeaderCallback, SendStreamHeaderRequest, SendStreamHeaderResponse, SendStreamTrailerCallback, SendStreamTrailerRequest, SendStreamTrailerResponse, SetDataChannelBufferedAmountLowThresholdRequest, SetDataChannelBufferedAmountLowThresholdResponse, SetLocalAttributesCallback, SetLocalAttributesRequest, SetLocalAttributesResponse, SetLocalMetadataCallback, SetLocalMetadataRequest, SetLocalMetadataResponse, SetLocalNameCallback, SetLocalNameRequest, SetLocalNameResponse, SetSubscribedRequest, SetSubscribedResponse, UnpublishTrackCallback, UnpublishTrackRequest, UnpublishTrackResponse } from "./room_pb.js";
-import { CreateAudioTrackRequest, CreateAudioTrackResponse, CreateVideoTrackRequest, CreateVideoTrackResponse, EnableRemoteTrackRequest, EnableRemoteTrackResponse, GetStatsCallback, GetStatsRequest, GetStatsResponse, LocalTrackMuteRequest, LocalTrackMuteResponse, TrackEvent } from "./track_pb.js";
+import { CreateAudioTrackRequest, CreateAudioTrackResponse, CreateVideoTrackRequest, CreateVideoTrackResponse, EnableRemoteTrackRequest, EnableRemoteTrackResponse, GetStatsCallback, GetStatsRequest, GetStatsResponse, LocalTrackMuteRequest, LocalTrackMuteResponse, SetTrackSubscriptionPermissionsRequest, SetTrackSubscriptionPermissionsResponse, TrackEvent } from "./track_pb.js";
 import { CaptureVideoFrameRequest, CaptureVideoFrameResponse, NewVideoSourceRequest, NewVideoSourceResponse, NewVideoStreamRequest, NewVideoStreamResponse, VideoConvertRequest, VideoConvertResponse, VideoStreamEvent, VideoStreamFromParticipantRequest, VideoStreamFromParticipantResponse } from "./video_frame_pb.js";
 import { AudioStreamEvent, AudioStreamFromParticipantRequest, AudioStreamFromParticipantResponse, CaptureAudioFrameCallback, CaptureAudioFrameRequest, CaptureAudioFrameResponse, ClearAudioBufferRequest, ClearAudioBufferResponse, FlushSoxResamplerRequest, FlushSoxResamplerResponse, NewAudioResamplerRequest, NewAudioResamplerResponse, NewAudioSourceRequest, NewAudioSourceResponse, NewAudioStreamRequest, NewAudioStreamResponse, NewSoxResamplerRequest, NewSoxResamplerResponse, PushSoxResamplerRequest, PushSoxResamplerResponse, RemixAndResampleRequest, RemixAndResampleResponse } from "./audio_frame_pb.js";
 import { E2eeRequest, E2eeResponse } from "./e2ee_pb.js";
@@ -187,6 +187,12 @@ export class FfiRequest extends Message<FfiRequest> {
      */
     value: GetStatsRequest;
     case: "getStats";
+  } | {
+    /**
+     * @generated from field: livekit.proto.SetTrackSubscriptionPermissionsRequest set_track_subscription_permissions = 48;
+     */
+    value: SetTrackSubscriptionPermissionsRequest;
+    case: "setTrackSubscriptionPermissions";
   } | {
     /**
      * Video
@@ -395,6 +401,7 @@ export class FfiRequest extends Message<FfiRequest> {
     { no: 17, name: "local_track_mute", kind: "message", T: LocalTrackMuteRequest, oneof: "message" },
     { no: 18, name: "enable_remote_track", kind: "message", T: EnableRemoteTrackRequest, oneof: "message" },
     { no: 19, name: "get_stats", kind: "message", T: GetStatsRequest, oneof: "message" },
+    { no: 48, name: "set_track_subscription_permissions", kind: "message", T: SetTrackSubscriptionPermissionsRequest, oneof: "message" },
     { no: 20, name: "new_video_stream", kind: "message", T: NewVideoStreamRequest, oneof: "message" },
     { no: 21, name: "new_video_source", kind: "message", T: NewVideoSourceRequest, oneof: "message" },
     { no: 22, name: "capture_video_frame", kind: "message", T: CaptureVideoFrameRequest, oneof: "message" },
@@ -563,6 +570,12 @@ export class FfiResponse extends Message<FfiResponse> {
      */
     value: GetStatsResponse;
     case: "getStats";
+  } | {
+    /**
+     * @generated from field: livekit.proto.SetTrackSubscriptionPermissionsResponse set_track_subscription_permissions = 47;
+     */
+    value: SetTrackSubscriptionPermissionsResponse;
+    case: "setTrackSubscriptionPermissions";
   } | {
     /**
      * Video
@@ -765,6 +778,7 @@ export class FfiResponse extends Message<FfiResponse> {
     { no: 17, name: "local_track_mute", kind: "message", T: LocalTrackMuteResponse, oneof: "message" },
     { no: 18, name: "enable_remote_track", kind: "message", T: EnableRemoteTrackResponse, oneof: "message" },
     { no: 19, name: "get_stats", kind: "message", T: GetStatsResponse, oneof: "message" },
+    { no: 47, name: "set_track_subscription_permissions", kind: "message", T: SetTrackSubscriptionPermissionsResponse, oneof: "message" },
     { no: 20, name: "new_video_stream", kind: "message", T: NewVideoStreamResponse, oneof: "message" },
     { no: 21, name: "new_video_source", kind: "message", T: NewVideoSourceResponse, oneof: "message" },
     { no: 22, name: "capture_video_frame", kind: "message", T: CaptureVideoFrameResponse, oneof: "message" },

package/src/proto/room_pb.ts

@@ -2986,6 +2986,11 @@ export class ParticipantDisconnected extends Message<ParticipantDisconnected> {
    */
   participantIdentity?: string;
 
+  /**
+   * @generated from field: required livekit.proto.DisconnectReason disconnect_reason = 2;
+   */
+  disconnectReason?: DisconnectReason;
+
   constructor(data?: PartialMessage<ParticipantDisconnected>) {
     super();
     proto2.util.initPartial(data, this);
@@ -2995,6 +3000,7 @@ export class ParticipantDisconnected extends Message<ParticipantDisconnected> {
   static readonly typeName = "livekit.proto.ParticipantDisconnected";
   static readonly fields: FieldList = proto2.util.newFieldList(() => [
     { no: 1, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 2, name: "disconnect_reason", kind: "enum", T: proto2.getEnumType(DisconnectReason), req: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ParticipantDisconnected {

package/src/proto/track_pb.ts

@@ -845,3 +845,138 @@ export class EnableRemoteTrackResponse extends Message<EnableRemoteTrackResponse
   }
 }
 
+/**
+ * @generated from message livekit.proto.SetTrackSubscriptionPermissionsRequest
+ */
+export class SetTrackSubscriptionPermissionsRequest extends Message<SetTrackSubscriptionPermissionsRequest> {
+  /**
+   * @generated from field: required uint64 local_participant_handle = 1;
+   */
+  localParticipantHandle?: bigint;
+
+  /**
+   * @generated from field: required bool all_participants_allowed = 2;
+   */
+  allParticipantsAllowed?: boolean;
+
+  /**
+   * @generated from field: repeated livekit.proto.ParticipantTrackPermission permissions = 3;
+   */
+  permissions: ParticipantTrackPermission[] = [];
+
+  constructor(data?: PartialMessage<SetTrackSubscriptionPermissionsRequest>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SetTrackSubscriptionPermissionsRequest";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "local_participant_handle", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+    { no: 2, name: "all_participants_allowed", kind: "scalar", T: 8 /* ScalarType.BOOL */, req: true },
+    { no: 3, name: "permissions", kind: "message", T: ParticipantTrackPermission, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetTrackSubscriptionPermissionsRequest {
+    return new SetTrackSubscriptionPermissionsRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetTrackSubscriptionPermissionsRequest {
+    return new SetTrackSubscriptionPermissionsRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetTrackSubscriptionPermissionsRequest {
+    return new SetTrackSubscriptionPermissionsRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SetTrackSubscriptionPermissionsRequest | PlainMessage<SetTrackSubscriptionPermissionsRequest> | undefined, b: SetTrackSubscriptionPermissionsRequest | PlainMessage<SetTrackSubscriptionPermissionsRequest> | undefined): boolean {
+    return proto2.util.equals(SetTrackSubscriptionPermissionsRequest, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.ParticipantTrackPermission
+ */
+export class ParticipantTrackPermission extends Message<ParticipantTrackPermission> {
+  /**
+   * The participant identity this permission applies to.
+   *
+   * @generated from field: required string participant_identity = 1;
+   */
+  participantIdentity?: string;
+
+  /**
+   * Grant permission to all all tracks. Takes precedence over allowedTrackSids.
+   *
+   * @generated from field: optional bool allow_all = 2;
+   */
+  allowAll?: boolean;
+
+  /**
+   * List of track sids to grant permission to.
+   *
+   * @generated from field: repeated string allowed_track_sids = 3;
+   */
+  allowedTrackSids: string[] = [];
+
+  constructor(data?: PartialMessage<ParticipantTrackPermission>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.ParticipantTrackPermission";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 2, name: "allow_all", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
+    { no: 3, name: "allowed_track_sids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ParticipantTrackPermission {
+    return new ParticipantTrackPermission().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ParticipantTrackPermission {
+    return new ParticipantTrackPermission().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ParticipantTrackPermission {
+    return new ParticipantTrackPermission().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ParticipantTrackPermission | PlainMessage<ParticipantTrackPermission> | undefined, b: ParticipantTrackPermission | PlainMessage<ParticipantTrackPermission> | undefined): boolean {
+    return proto2.util.equals(ParticipantTrackPermission, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.SetTrackSubscriptionPermissionsResponse
+ */
+export class SetTrackSubscriptionPermissionsResponse extends Message<SetTrackSubscriptionPermissionsResponse> {
+  constructor(data?: PartialMessage<SetTrackSubscriptionPermissionsResponse>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SetTrackSubscriptionPermissionsResponse";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetTrackSubscriptionPermissionsResponse {
+    return new SetTrackSubscriptionPermissionsResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetTrackSubscriptionPermissionsResponse {
+    return new SetTrackSubscriptionPermissionsResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetTrackSubscriptionPermissionsResponse {
+    return new SetTrackSubscriptionPermissionsResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SetTrackSubscriptionPermissionsResponse | PlainMessage<SetTrackSubscriptionPermissionsResponse> | undefined, b: SetTrackSubscriptionPermissionsResponse | PlainMessage<SetTrackSubscriptionPermissionsResponse> | undefined): boolean {
+    return proto2.util.equals(SetTrackSubscriptionPermissionsResponse, a, b);
+  }
+}
+

package/src/proto/video_frame_pb.ts

@@ -753,7 +753,7 @@ export class VideoBufferInfo extends Message<VideoBufferInfo> {
   /**
    * only for packed formats
    *
-   * @generated from field: required uint32 stride = 6;
+   * @generated from field: optional uint32 stride = 6;
    */
   stride?: number;
 
@@ -774,7 +774,7 @@ export class VideoBufferInfo extends Message<VideoBufferInfo> {
     { no: 2, name: "width", kind: "scalar", T: 13 /* ScalarType.UINT32 */, req: true },
     { no: 3, name: "height", kind: "scalar", T: 13 /* ScalarType.UINT32 */, req: true },
     { no: 4, name: "data_ptr", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
-    { no: 6, name: "stride", kind: "scalar", T: 13 /* ScalarType.UINT32 */, req: true },
+    { no: 6, name: "stride", kind: "scalar", T: 13 /* ScalarType.UINT32 */, opt: true },
     { no: 7, name: "components", kind: "message", T: VideoBufferInfo_ComponentInfo, repeated: true },
   ]);
 

package/src/room.ts

@@ -21,24 +21,22 @@ import { LocalParticipant, RemoteParticipant } from './participant.js';
 import { EncryptionState } from './proto/e2ee_pb.js';
 import type { FfiEvent } from './proto/ffi_pb.js';
 import type { DisconnectReason, OwnedParticipant } from './proto/participant_pb.js';
+import type { DataStream_Trailer } from './proto/room_pb.js';
 import {
   type ConnectCallback,
+  ConnectRequest,
   type ConnectResponse,
   type ConnectionQuality,
+  ConnectionState,
+  ContinualGatheringPolicy,
   type DataPacketKind,
   type DataStream_Chunk,
   type DataStream_Header,
-  DataStream_Trailer,
   type DisconnectResponse,
   RoomOptions as FfiRoomOptions,
   type IceServer,
-  type RoomInfo,
-} from './proto/room_pb.js';
-import {
-  ConnectRequest,
-  ConnectionState,
-  ContinualGatheringPolicy,
   IceTransportType,
+  type RoomInfo,
 } from './proto/room_pb.js';
 import { TrackKind } from './proto/track_pb.js';
 import type { LocalTrack, RemoteTrack } from './track.js';
@@ -249,7 +247,8 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       this.emit(RoomEvent.ParticipantConnected, participant);
     } else if (ev.case == 'participantDisconnected') {
       const participant = this.remoteParticipants.get(ev.value.participantIdentity!);
-      this.remoteParticipants.delete(participant!.identity!);
+      this.remoteParticipants.delete(participant!.identity);
+      participant!.info.disconnectReason = ev.value.disconnectReason;
       this.emit(RoomEvent.ParticipantDisconnected, participant!);
     } else if (ev.case == 'localTrackPublished') {
       const publication = this.localParticipant!.trackPublications.get(ev.value.trackSid!);

package/src/utils.test.ts

@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+import { describe, expect, it } from 'vitest';
+import { splitUtf8 } from './utils.js';
+
+describe('splitUtf8', () => {
+  it('splits a string into chunks of the given size', () => {
+    expect(splitUtf8('hello world', 5)).toEqual([
+      new TextEncoder().encode('hello'),
+      new TextEncoder().encode(' worl'),
+      new TextEncoder().encode('d'),
+    ]);
+  });
+
+  it('splits a string with special characters into chunks of the given size', () => {
+    expect(splitUtf8('héllo wörld', 5)).toEqual([
+      new TextEncoder().encode('héll'),
+      new TextEncoder().encode('o wö'),
+      new TextEncoder().encode('rld'),
+    ]);
+  });
+
+  it('splits a string with multi-byte utf8 characters correctly', () => {
+    expect(splitUtf8('こんにちは世界', 5)).toEqual([
+      new TextEncoder().encode('こ'),
+      new TextEncoder().encode('ん'),
+      new TextEncoder().encode('に'),
+      new TextEncoder().encode('ち'),
+      new TextEncoder().encode('は'),
+      new TextEncoder().encode('世'),
+      new TextEncoder().encode('界'),
+    ]);
+  });
+
+  it('handles a string with a single multi-byte utf8 character', () => {
+    expect(splitUtf8('😊', 5)).toEqual([new TextEncoder().encode('😊')]);
+  });
+
+  it('handles a string with mixed single and multi-byte utf8 characters', () => {
+    expect(splitUtf8('a😊b', 4)).toEqual([
+      new TextEncoder().encode('a'),
+      new TextEncoder().encode('😊'),
+      new TextEncoder().encode('b'),
+    ]);
+  });
+
+  it('handles an empty string', () => {
+    expect(splitUtf8('', 5)).toEqual([]);
+  });
+});

package/src/utils.ts

@@ -16,18 +16,27 @@ export function numberToBigInt<T extends number | undefined>(
   return (value !== undefined ? BigInt(value) : undefined) as T extends number ? bigint : undefined;
 }
 
-export function splitUtf8(s: string, n: number): string[] {
+export function splitUtf8(s: string, n: number): Uint8Array[] {
+  if (n < 4) {
+    throw new Error('n must be at least 4 due to utf8 encoding rules');
+  }
   // adapted from https://stackoverflow.com/a/6043797
-  const result: string[] = [];
-  while (s.length > n) {
+  const result: Uint8Array[] = [];
+  let encoded = new TextEncoder().encode(s);
+  while (encoded.length > n) {
     let k = n;
-    // Move back to find the start of a UTF-8 character
-    while ((s.charCodeAt(k) & 0xc0) === 0x80) {
+    while (k > 0) {
+      const byte = encoded[k];
+      if (byte !== undefined && (byte & 0xc0) !== 0x80) {
+        break;
+      }
       k--;
     }
-    result.push(s.slice(0, k));
-    s = s.slice(k);
+    result.push(encoded.slice(0, k));
+    encoded = encoded.slice(k);
+  }
+  if (encoded.length > 0) {
+    result.push(encoded);
   }
-  result.push(s);
   return result;
 }

package/src/version.ts

@@ -1 +1 @@
-export const SDK_VERSION = "0.13.4";
+export const SDK_VERSION = "0.13.6";