@livekit/rtc-node 0.10.4 → 0.11.0

package/src/room.ts

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
+import { create } from '@bufbuild/protobuf';
 import type { TypedEventEmitter as TypedEmitter } from '@livekit/typed-emitter';
 import EventEmitter from 'events';
 import type { E2EEOptions } from './e2ee.js';
@@ -18,11 +19,12 @@ import type {
   DataPacketKind,
   DisconnectReason,
   DisconnectResponse,
+  RoomOptions as FfiRoomOptions,
   IceServer,
   RoomInfo,
 } from './proto/room_pb.js';
 import {
-  ConnectRequest,
+  ConnectRequestSchema,
   ConnectionState,
   ContinualGatheringPolicy,
   IceTransportType,
@@ -53,18 +55,20 @@ export interface RoomOptions {
   rtcConfig?: RtcConfiguration;
 }
 
-export const defaultRoomOptions: RoomOptions = {
+export const defaultRoomOptions = {
   autoSubscribe: true,
   dynacast: false,
   e2ee: undefined,
   rtcConfig: undefined,
-};
+  adaptiveStream: false,
+  joinRetries: 1,
+} satisfies Omit<FfiRoomOptions, '$typeName'>;
 
 export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>) {
-  private info: RoomInfo;
+  private info?: RoomInfo;
   private ffiHandle?: FfiHandle;
 
-  e2eeManager: E2EEManager;
+  e2eeManager?: E2EEManager;
   connectionState: ConnectionState = ConnectionState.CONN_DISCONNECTED;
 
   remoteParticipants: Map<string, RemoteParticipant> = new Map();
@@ -74,12 +78,12 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     super();
   }
 
-  get name(): string {
-    return this.info.name;
+  get name(): string | undefined {
+    return this.info?.name;
   }
 
-  get metadata(): string {
-    return this.info.metadata;
+  get metadata(): string | undefined {
+    return this.info?.metadata;
   }
 
   get isConnected(): boolean {
@@ -87,28 +91,34 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
   }
 
   async getSid(): Promise<string> {
-    return this.info.sid; // TODO update this to handle async room updates once rust protocol has been updated
+    if (!this.isConnected) {
+      return '';
+    }
+    if (this.info && this.info.sid !== '') {
+      return this.info.sid;
+    }
+    return new Promise((resolve, reject) => {
+      const handleRoomUpdate = (sid: string) => {
+        if (sid !== '') {
+          this.off(RoomEvent.RoomSidChanged, handleRoomUpdate);
+          resolve(sid);
+        }
+      };
+      this.on(RoomEvent.RoomSidChanged, handleRoomUpdate);
+      this.once(RoomEvent.Disconnected, () => {
+        this.off(RoomEvent.RoomSidChanged, handleRoomUpdate);
+        reject('Room disconnected before room server id was available');
+      });
+    });
   }
 
   async connect(url: string, token: string, opts?: RoomOptions) {
     const options = { ...defaultRoomOptions, ...opts };
 
-    const req = new ConnectRequest({
+    const req = create(ConnectRequestSchema, {
       url: url,
       token: token,
-      options: {
-        autoSubscribe: options.autoSubscribe,
-        dynacast: options.dynacast,
-        e2ee: {
-          encryptionType: options.e2ee?.encryptionType,
-          keyProviderOptions: {
-            failureTolerance: options.e2ee?.keyProviderOptions?.failureTolerance,
-            ratchetSalt: options.e2ee?.keyProviderOptions?.ratchetSalt,
-            ratchetWindowSize: options.e2ee?.keyProviderOptions?.ratchetWindowSize,
-            sharedKey: options.e2ee?.keyProviderOptions?.sharedKey,
-          },
-        },
-      },
+      options,
     });
 
     const res = FfiClient.instance.request<ConnectResponse>({
@@ -122,19 +132,23 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       return ev.message.case == 'connect' && ev.message.value.asyncId == res.asyncId;
     });
 
-    if (cb.error) {
-      throw new ConnectError(cb.error);
+    if (cb.message.case !== 'result') {
+      throw new ConnectError(cb.message.value ?? 'Unknown error');
     }
 
-    this.ffiHandle = new FfiHandle(cb.room.handle.id);
-    this.e2eeManager = new E2EEManager(this.ffiHandle.handle, options.e2ee);
+    const { room, localParticipant, participants } = cb.message.value;
+
+    this.ffiHandle = new FfiHandle(room!.handle!.id);
+    if (options.e2ee) {
+      this.e2eeManager = new E2EEManager(this.ffiHandle.handle, options.e2ee);
+    }
 
-    this.info = cb.room.info;
+    this.info = room!.info;
     this.connectionState = ConnectionState.CONN_CONNECTED;
-    this.localParticipant = new LocalParticipant(cb.localParticipant);
+    this.localParticipant = new LocalParticipant(localParticipant!);
 
-    for (const pt of cb.participants) {
-      const rp = this.createRemoteParticipant(pt.participant);
+    for (const pt of participants) {
+      const rp = this.createRemoteParticipant(pt.participant!);
 
       for (const pub of pt.publications) {
         const publication = new RemoteTrackPublication(pub);
@@ -146,7 +160,7 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
   }
 
   async disconnect() {
-    if (!this.isConnected) {
+    if (!this.isConnected || !this.ffiHandle) {
       return;
     }
 
@@ -164,7 +178,25 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
   }
 
   private onFfiEvent = (ffiEvent: FfiEvent) => {
-    if (
+    if (!this.localParticipant || !this.ffiHandle || !this.info) {
+      throw TypeError('cannot handle ffi events before connectCallback');
+    }
+
+    if (ffiEvent.message.case == 'rpcMethodInvocation') {
+      if (
+        ffiEvent.message.value.localParticipantHandle == this.localParticipant.ffi_handle.handle
+      ) {
+        this.localParticipant.handleRpcMethodInvocation(
+          ffiEvent.message.value.invocationId,
+          ffiEvent.message.value.method,
+          ffiEvent.message.value.requestId,
+          ffiEvent.message.value.callerIdentity,
+          ffiEvent.message.value.payload,
+          ffiEvent.message.value.responseTimeoutMs,
+        );
+      }
+      return;
+    } else if (
       ffiEvent.message.case != 'roomEvent' ||
       ffiEvent.message.value.roomHandle != this.ffiHandle.handle
     ) {
@@ -173,66 +205,88 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
 
     const ev = ffiEvent.message.value.message;
     if (ev.case == 'participantConnected') {
-      const participant = this.createRemoteParticipant(ev.value.info);
+      const participant = this.createRemoteParticipant(ev.value.info!);
       this.remoteParticipants.set(participant.identity, participant);
       this.emit(RoomEvent.ParticipantConnected, participant);
     } else if (ev.case == 'participantDisconnected') {
       const participant = this.remoteParticipants.get(ev.value.participantIdentity);
-      this.remoteParticipants.delete(participant.identity);
-      this.emit(RoomEvent.ParticipantDisconnected, participant);
+      if (participant) {
+        this.remoteParticipants.delete(participant.identity);
+        this.emit(RoomEvent.ParticipantDisconnected, participant);
+      }
     } else if (ev.case == 'localTrackPublished') {
       const publication = this.localParticipant.trackPublications.get(ev.value.trackSid);
+      if (!publication) {
+        throw new TypeError('local track publication not found');
+      }
       this.emit(RoomEvent.LocalTrackPublished, publication, this.localParticipant);
     } else if (ev.case == 'localTrackUnpublished') {
       const publication = this.localParticipant.trackPublications.get(ev.value.publicationSid);
       this.localParticipant.trackPublications.delete(ev.value.publicationSid);
-      this.emit(RoomEvent.LocalTrackUnpublished, publication, this.localParticipant);
+      if (publication) {
+        this.emit(RoomEvent.LocalTrackUnpublished, publication, this.localParticipant);
+      }
     } else if (ev.case == 'localTrackSubscribed') {
       const publication = this.localParticipant.trackPublications.get(ev.value.trackSid);
+      if (!publication) {
+        throw new TypeError('local track publication not found');
+      }
       publication.resolveFirstSubscription();
-      this.emit(RoomEvent.LocalTrackSubscribed, publication.track);
+      this.emit(RoomEvent.LocalTrackSubscribed, publication.track!);
     } else if (ev.case == 'trackPublished') {
-      const participant = this.remoteParticipants.get(ev.value.participantIdentity);
-      const publication = new RemoteTrackPublication(ev.value.publication);
+      const participant = this.requireRemoteParticipant(ev.value.participantIdentity);
+      const publication = new RemoteTrackPublication(ev.value.publication!);
       participant.trackPublications.set(publication.sid, publication);
       this.emit(RoomEvent.TrackPublished, publication, participant);
     } else if (ev.case == 'trackUnpublished') {
-      const participant = this.remoteParticipants.get(ev.value.participantIdentity);
+      const participant = this.requireRemoteParticipant(ev.value.participantIdentity);
       const publication = participant.trackPublications.get(ev.value.publicationSid);
       participant.trackPublications.delete(ev.value.publicationSid);
-      this.emit(RoomEvent.TrackUnpublished, publication, participant);
+      if (publication) {
+        this.emit(RoomEvent.TrackUnpublished, publication, participant);
+      }
     } else if (ev.case == 'trackSubscribed') {
-      const ownedTrack = ev.value.track;
-      const participant = this.remoteParticipants.get(ev.value.participantIdentity);
-      const publication = participant.trackPublications.get(ownedTrack.info.sid);
+      const ownedTrack = ev.value.track!;
+      const trackInfo = ownedTrack.info!;
+      const { participant, publication } = this.requirePublicationOfRemoteParticipant(
+        ev.value.participantIdentity,
+        trackInfo.sid,
+      );
       publication.subscribed = true;
-      if (ownedTrack.info.kind == TrackKind.KIND_VIDEO) {
+      if (trackInfo.kind == TrackKind.KIND_VIDEO) {
         publication.track = new RemoteVideoTrack(ownedTrack);
-      } else if (ownedTrack.info.kind == TrackKind.KIND_AUDIO) {
+      } else if (trackInfo.kind == TrackKind.KIND_AUDIO) {
         publication.track = new RemoteAudioTrack(ownedTrack);
       }
 
-      this.emit(RoomEvent.TrackSubscribed, publication.track, publication, participant);
+      this.emit(RoomEvent.TrackSubscribed, publication.track!, publication, participant);
     } else if (ev.case == 'trackUnsubscribed') {
-      const participant = this.remoteParticipants.get(ev.value.participantIdentity);
-      const publication = participant.trackPublications.get(ev.value.trackSid);
+      const { participant, publication } = this.requirePublicationOfRemoteParticipant(
+        ev.value.participantIdentity,
+        ev.value.trackSid,
+      );
+      const track = publication.track!;
       publication.track = undefined;
       publication.subscribed = false;
-      this.emit(RoomEvent.TrackUnsubscribed, publication.track, publication, participant);
+      this.emit(RoomEvent.TrackUnsubscribed, track, publication, participant);
     } else if (ev.case == 'trackSubscriptionFailed') {
-      const participant = this.remoteParticipants.get(ev.value.participantIdentity);
+      const participant = this.requireRemoteParticipant(ev.value.participantIdentity);
       this.emit(RoomEvent.TrackSubscriptionFailed, ev.value.trackSid, participant, ev.value.error);
     } else if (ev.case == 'trackMuted') {
-      const participant = this.remoteParticipants.get(ev.value.participantIdentity);
-      const publication = participant.trackPublications.get(ev.value.trackSid);
+      const { participant, publication } = this.requirePublicationOfParticipant(
+        ev.value.participantIdentity,
+        ev.value.trackSid,
+      );
       publication.info.muted = true;
       if (publication.track) {
         publication.track.info.muted = true;
       }
       this.emit(RoomEvent.TrackMuted, publication, participant);
     } else if (ev.case == 'trackUnmuted') {
-      const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity);
-      const publication = participant.trackPublications.get(ev.value.trackSid);
+      const { participant, publication } = this.requirePublicationOfParticipant(
+        ev.value.participantIdentity,
+        ev.value.trackSid,
+      );
       publication.info.muted = false;
       if (publication.track) {
         publication.track.info.muted = false;
@@ -240,32 +294,45 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       this.emit(RoomEvent.TrackUnmuted, publication, participant);
     } else if (ev.case == 'activeSpeakersChanged') {
       const activeSpeakers = ev.value.participantIdentities.map((identity) =>
-        this.retrieveParticipantByIdentity(identity),
+        this.requireParticipantByIdentity(identity),
       );
       this.emit(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
     } else if (ev.case == 'roomMetadataChanged') {
       this.info.metadata = ev.value.metadata;
       this.emit(RoomEvent.RoomMetadataChanged, this.info.metadata);
     } else if (ev.case == 'participantMetadataChanged') {
-      const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity);
+      const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
       participant.info.metadata = ev.value.metadata;
       this.emit(RoomEvent.ParticipantMetadataChanged, participant.metadata, participant);
     } else if (ev.case == 'participantNameChanged') {
-      const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity);
+      const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
       participant.info.name = ev.value.name;
       this.emit(RoomEvent.ParticipantNameChanged, participant.name, participant);
     } else if (ev.case == 'participantAttributesChanged') {
-      const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity);
-      participant.info.attributes = ev.value.attributes;
+      const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
+      participant.info.attributes = ev.value.attributes.reduce(
+        (acc, value) => {
+          acc[value.key] = value.value;
+          return acc;
+        },
+        {} as Record<string, string>,
+      );
       if (Object.keys(ev.value.changedAttributes).length > 0) {
-        this.emit(RoomEvent.ParticipantAttributesChanged, ev.value.changedAttributes, participant);
+        const changedAttributes = ev.value.changedAttributes.reduce(
+          (acc, value) => {
+            acc[value.key] = value.value;
+            return acc;
+          },
+          {} as Record<string, string>,
+        );
+        this.emit(RoomEvent.ParticipantAttributesChanged, changedAttributes, participant);
       }
     } else if (ev.case == 'connectionQualityChanged') {
-      const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity);
+      const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
       this.emit(RoomEvent.ConnectionQualityChanged, ev.value.quality, participant);
     } else if (ev.case == 'chatMessage') {
       const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity);
-      const { id, message: messageText, timestamp, editTimestamp, generated } = ev.value.message;
+      const { id, message: messageText, timestamp, editTimestamp, generated } = ev.value.message!;
       const message: ChatMessage = {
         id,
         message: messageText,
@@ -280,11 +347,9 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       const dataPacket = ev.value.value;
       switch (dataPacket.case) {
         case 'user':
-          const buffer = FfiClient.instance.copyBuffer(
-            dataPacket.value.data.data.dataPtr,
-            Number(dataPacket.value.data.data.dataLen),
-          );
-          new FfiHandle(dataPacket.value.data.handle.id).dispose();
+          const data = dataPacket.value.data!.data!;
+          const buffer = FfiClient.instance.copyBuffer(data.dataPtr, Number(data.dataLen));
+          new FfiHandle(dataPacket.value.data!.handle!.id).dispose();
           this.emit(
             RoomEvent.DataReceived,
             buffer,
@@ -316,24 +381,62 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       this.emit(RoomEvent.Reconnecting);
     } else if (ev.case == 'reconnected') {
       this.emit(RoomEvent.Reconnected);
+    } else if (ev.case == 'roomSidChanged') {
+      this.emit(RoomEvent.RoomSidChanged, ev.value.sid);
     }
   };
 
-  private retrieveParticipantByIdentity(identity: string): Participant {
-    if (this.localParticipant.identity === identity) {
+  private retrieveParticipantByIdentity(identity: string): Participant | undefined {
+    if (this.localParticipant?.identity === identity) {
       return this.localParticipant;
     } else {
       return this.remoteParticipants.get(identity);
     }
   }
 
+  private requireParticipantByIdentity(identity: string): Participant {
+    if (this.localParticipant?.identity === identity) {
+      return this.localParticipant;
+    } else if (this.remoteParticipants.has(identity)) {
+      return this.remoteParticipants.get(identity)!;
+    } else {
+      throw new TypeError(`participant ${identity} not found`);
+    }
+  }
+
+  private requireRemoteParticipant(identity: string) {
+    const participant = this.remoteParticipants.get(identity);
+    if (!participant) {
+      throw new TypeError(`participant ${identity} not found`);
+    }
+    return participant;
+  }
+
+  private requirePublicationOfParticipant(identity: string, trackSid: string) {
+    const participant = this.requireParticipantByIdentity(identity);
+    const publication = participant.trackPublications.get(trackSid);
+    if (!publication) {
+      throw new TypeError(`publication ${trackSid} not found`);
+    }
+    return { participant, publication };
+  }
+
+  private requirePublicationOfRemoteParticipant(identity: string, trackSid: string) {
+    const participant = this.requireRemoteParticipant(identity);
+    const publication = participant.trackPublications.get(trackSid);
+    if (!publication) {
+      throw new TypeError(`publication ${trackSid} not found`);
+    }
+    return { participant, publication };
+  }
+
   private createRemoteParticipant(ownedInfo: OwnedParticipant) {
-    if (this.remoteParticipants.has(ownedInfo.info.identity)) {
+    if (this.remoteParticipants.has(ownedInfo.info!.identity)) {
       throw new Error('Participant already exists');
     }
 
     const participant = new RemoteParticipant(ownedInfo);
-    this.remoteParticipants.set(ownedInfo.info.identity, participant);
+    this.remoteParticipants.set(ownedInfo.info!.identity, participant);
     return participant;
   }
 }
@@ -374,6 +477,7 @@ export type RoomCallbacks = {
   trackUnmuted: (publication: TrackPublication, participant: Participant) => void;
   activeSpeakersChanged: (speakers: Participant[]) => void;
   roomMetadataChanged: (metadata: string) => void;
+  roomInfoUpdated: (info: RoomInfo) => void;
   participantMetadataChanged: (metadata: string | undefined, participant: Participant) => void;
   participantNameChanged: (name: string, participant: Participant) => void;
   participantAttributesChanged: (
@@ -388,13 +492,14 @@ export type RoomCallbacks = {
     topic?: string,
   ) => void;
   chatMessage: (message: ChatMessage, participant?: Participant) => void;
-  dtmfReceived: (code: number, digit: string, participant: RemoteParticipant) => void;
+  dtmfReceived: (code: number, digit: string, participant?: RemoteParticipant) => void;
   encryptionError: (error: Error) => void;
   connectionStateChanged: (state: ConnectionState) => void;
   connected: () => void;
   disconnected: (reason: DisconnectReason) => void;
   reconnecting: () => void;
   reconnected: () => void;
+  roomSidChanged: (sid: string) => void;
 };
 
 export enum RoomEvent {
@@ -412,6 +517,7 @@ export enum RoomEvent {
   TrackUnmuted = 'trackUnmuted',
   ActiveSpeakersChanged = 'activeSpeakersChanged',
   RoomMetadataChanged = 'roomMetadataChanged',
+  RoomSidChanged = 'roomSidChanged',
   ParticipantMetadataChanged = 'participantMetadataChanged',
   ParticipantNameChanged = 'participantNameChanged',
   ParticipantAttributesChanged = 'participantAttributesChanged',

package/src/rpc.ts

@@ -0,0 +1,121 @@
+// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+import type { RpcError as RpcError_Proto } from './proto/rpc_pb.js';
+
+/** Parameters for initiating an RPC call */
+export interface PerformRpcParams {
+  /** The `identity` of the destination participant */
+  destinationIdentity: string;
+  /** The method name to call */
+  method: string;
+  /** The method payload */
+  payload: string;
+  /** Timeout for receiving a response after initial connection (milliseconds). Default: 10000 */
+  responseTimeout?: number;
+}
+
+/**
+ * Data passed to method handler for incoming RPC invocations
+ */
+export interface RpcInvocationData {
+  /**
+   * The unique request ID. Will match at both sides of the call, useful for debugging or logging.
+   */
+  requestId: string;
+
+  /**
+   * The unique participant identity of the caller.
+   */
+  callerIdentity: string;
+
+  /**
+   * The payload of the request. User-definable format, typically JSON.
+   */
+  payload: string;
+
+  /**
+   * The maximum time the caller will wait for a response.
+   */
+  responseTimeout: number;
+}
+
+/**
+ * Specialized error handling for RPC methods.
+ *
+ * Instances of this type, when thrown in a method handler, will have their `message`
+ * serialized and sent across the wire. The caller will receive an equivalent error on the other side.
+ *
+ * Built-in types are included but developers may use any string, with a max length of 256 bytes.
+ */
+
+export class RpcError extends Error {
+  code: typeof RpcError.ErrorCode | number;
+  data?: string;
+
+  /**
+   * Creates an error object with the given code and message, plus an optional data payload.
+   *
+   * If thrown in an RPC method handler, the error will be sent back to the caller.
+   *
+   * Error codes 1001-1999 are reserved for built-in errors (see RpcError.ErrorCode for their meanings).
+   */
+  constructor(code: number, message: string, data?: string) {
+    super(message);
+    this.code = code;
+    this.message = message;
+    this.data = data;
+  }
+
+  static fromProto(proto: RpcError_Proto) {
+    return new RpcError(proto.code, proto.message, proto.data);
+  }
+
+  toProto() {
+    return {
+      code: this.code as number,
+      message: this.message,
+      data: this.data,
+    } as RpcError_Proto;
+  }
+
+  static ErrorCode = {
+    APPLICATION_ERROR: 1500,
+    CONNECTION_TIMEOUT: 1501,
+    RESPONSE_TIMEOUT: 1502,
+    RECIPIENT_DISCONNECTED: 1503,
+    RESPONSE_PAYLOAD_TOO_LARGE: 1504,
+    SEND_FAILED: 1505,
+
+    UNSUPPORTED_METHOD: 1400,
+    RECIPIENT_NOT_FOUND: 1401,
+    REQUEST_PAYLOAD_TOO_LARGE: 1402,
+    UNSUPPORTED_SERVER: 1403,
+  } as const;
+
+  /**
+   * @internal
+   */
+  static ErrorMessage: Record<keyof typeof RpcError.ErrorCode, string> = {
+    APPLICATION_ERROR: 'Application error in method handler',
+    CONNECTION_TIMEOUT: 'Connection timeout',
+    RESPONSE_TIMEOUT: 'Response timeout',
+    RECIPIENT_DISCONNECTED: 'Recipient disconnected',
+    RESPONSE_PAYLOAD_TOO_LARGE: 'Response payload too large',
+    SEND_FAILED: 'Failed to send',
+
+    UNSUPPORTED_METHOD: 'Method not supported at destination',
+    RECIPIENT_NOT_FOUND: 'Recipient not found',
+    REQUEST_PAYLOAD_TOO_LARGE: 'Request payload too large',
+    UNSUPPORTED_SERVER: 'RPC not supported by server',
+  } as const;
+
+  /**
+   * Creates an error object from the code, with an auto-populated message.
+   *
+   * @internal
+   */
+  static builtIn(key: keyof typeof RpcError.ErrorCode, data?: string): RpcError {
+    return new RpcError(RpcError.ErrorCode[key], RpcError.ErrorMessage[key], data);
+  }
+}

package/src/track.ts

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
+import { create } from '@bufbuild/protobuf';
 import type { AudioSource } from './audio_source.js';
 import { FfiClient, FfiHandle } from './ffi_client.js';
 import type {
@@ -11,7 +12,7 @@ import type {
   TrackInfo,
   TrackKind,
 } from './proto/track_pb.js';
-import { CreateAudioTrackRequest, CreateVideoTrackRequest } from './proto/track_pb.js';
+import { CreateAudioTrackRequestSchema, CreateVideoTrackRequestSchema } from './proto/track_pb.js';
 import type { VideoSource } from './video_source.js';
 
 export abstract class Track {
@@ -22,8 +23,8 @@ export abstract class Track {
   ffi_handle: FfiHandle;
 
   constructor(owned: OwnedTrack) {
-    this.info = owned.info;
-    this.ffi_handle = new FfiHandle(owned.handle.id);
+    this.info = owned.info!;
+    this.ffi_handle = new FfiHandle(owned.handle!.id);
   }
 
   get sid(): string {
@@ -53,7 +54,7 @@ export class LocalAudioTrack extends Track {
   }
 
   static createAudioTrack(name: string, source: AudioSource): LocalAudioTrack {
-    const req = new CreateAudioTrackRequest({
+    const req = create(CreateAudioTrackRequestSchema, {
       name: name,
       sourceHandle: source.ffiHandle.handle,
     });
@@ -62,7 +63,7 @@ export class LocalAudioTrack extends Track {
       message: { case: 'createAudioTrack', value: req },
     });
 
-    return new LocalAudioTrack(res.track);
+    return new LocalAudioTrack(res.track!);
   }
 }
 
@@ -72,7 +73,7 @@ export class LocalVideoTrack extends Track {
   }
 
   static createVideoTrack(name: string, source: VideoSource): LocalVideoTrack {
-    const req = new CreateVideoTrackRequest({
+    const req = create(CreateVideoTrackRequestSchema, {
       name: name,
       sourceHandle: source.ffiHandle.handle,
     });
@@ -81,7 +82,7 @@ export class LocalVideoTrack extends Track {
       message: { case: 'createVideoTrack', value: req },
     });
 
-    return new LocalVideoTrack(res.track);
+    return new LocalVideoTrack(res.track!);
   }
 }
 

package/src/track_publication.ts

@@ -1,11 +1,12 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
+import { create } from '@bufbuild/protobuf';
 import { FfiClient } from './ffi_client.js';
 import { FfiHandle } from './napi/native.js';
 import type { EncryptionType } from './proto/e2ee_pb.js';
 import type { SetSubscribedResponse } from './proto/room_pb.js';
-import { SetSubscribedRequest } from './proto/room_pb.js';
+import { SetSubscribedRequestSchema } from './proto/room_pb.js';
 import type {
   OwnedTrackPublication,
   TrackKind,
@@ -23,8 +24,8 @@ export abstract class TrackPublication {
   track?: Track;
 
   constructor(ownedInfo: OwnedTrackPublication) {
-    this.info = ownedInfo.info;
-    this.ffiHandle = new FfiHandle(ownedInfo.handle.id);
+    this.info = ownedInfo.info!;
+    this.ffiHandle = new FfiHandle(ownedInfo!.handle!.id);
   }
 
   get sid(): string {
@@ -100,7 +101,7 @@ export class RemoteTrackPublication extends TrackPublication {
   }
 
   setSubscribed(subscribed: boolean) {
-    const req = new SetSubscribedRequest({
+    const req = create(SetSubscribedRequestSchema, {
       subscribe: subscribed,
       publicationHandle: this.ffiHandle.handle,
     });

package/src/version.ts

@@ -0,0 +1 @@
+export const SDK_VERSION = "0.11.0";