@livekit/rtc-node 0.12.1 → 0.13.0

package/src/room.ts

@@ -1,7 +1,6 @@
 // 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';
@@ -11,20 +10,19 @@ import type { Participant } from './participant.js';
 import { LocalParticipant, RemoteParticipant } from './participant.js';
 import { EncryptionState } from './proto/e2ee_pb.js';
 import type { FfiEvent } from './proto/ffi_pb.js';
-import type { OwnedParticipant } from './proto/participant_pb.js';
-import type {
-  ConnectCallback,
-  ConnectResponse,
-  ConnectionQuality,
-  DataPacketKind,
-  DisconnectReason,
-  DisconnectResponse,
+import type { DisconnectReason, OwnedParticipant } from './proto/participant_pb.js';
+import {
+  type ConnectCallback,
+  type ConnectResponse,
+  type ConnectionQuality,
+  type DataPacketKind,
+  type DisconnectResponse,
   RoomOptions as FfiRoomOptions,
-  IceServer,
-  RoomInfo,
+  type IceServer,
+  type RoomInfo,
 } from './proto/room_pb.js';
 import {
-  ConnectRequestSchema,
+  ConnectRequest,
   ConnectionState,
   ContinualGatheringPolicy,
   IceTransportType,
@@ -55,14 +53,14 @@ export interface RoomOptions {
   rtcConfig?: RtcConfiguration;
 }
 
-export const defaultRoomOptions = {
+export const defaultRoomOptions = new FfiRoomOptions({
   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;
@@ -90,32 +88,14 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     return this.ffiHandle != undefined && this.connectionState != ConnectionState.CONN_DISCONNECTED;
   }
 
-  async getSid(): Promise<string> {
-    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 getSid(): Promise<string | undefined> {
+    return this.info?.sid; // TODO update this to handle async room updates once rust protocol has been updated
   }
 
   async connect(url: string, token: string, opts?: RoomOptions) {
     const options = { ...defaultRoomOptions, ...opts };
 
-    const req = create(ConnectRequestSchema, {
+    const req = new ConnectRequest({
       url: url,
       token: token,
       options,
@@ -132,35 +112,42 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       return ev.message.case == 'connect' && ev.message.value.asyncId == res.asyncId;
     });
 
-    if (cb.message.case !== 'result') {
-      throw new ConnectError(cb.message.value ?? 'Unknown error');
-    }
-
-    const { room, localParticipant, participants } = cb.message.value;
+    switch (cb.message.case) {
+      case 'result':
+        this.ffiHandle = new FfiHandle(cb.message.value.room!.handle!.id!);
+        this.e2eeManager = new E2EEManager(this.ffiHandle.handle, {
+          keyProviderOptions: {
+            sharedKey: options.e2ee?.keyProviderOptions?.sharedKey,
+            ratchetSalt: options.e2ee!.keyProviderOptions!.ratchetSalt!,
+            ratchetWindowSize: options.e2ee!.keyProviderOptions!.ratchetWindowSize!,
+            failureTolerance: options.e2ee!.keyProviderOptions!.failureTolerance!,
+          },
+          encryptionType: options.e2ee!.encryptionType!,
+        });
 
-    this.ffiHandle = new FfiHandle(room!.handle!.id);
-    if (options.e2ee) {
-      this.e2eeManager = new E2EEManager(this.ffiHandle.handle, options.e2ee);
-    }
+        this.info = cb.message.value.room!.info;
+        this.connectionState = ConnectionState.CONN_CONNECTED;
+        this.localParticipant = new LocalParticipant(cb.message.value.localParticipant!);
 
-    this.info = room!.info;
-    this.connectionState = ConnectionState.CONN_CONNECTED;
-    this.localParticipant = new LocalParticipant(localParticipant!);
+        for (const pt of cb.message.value.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);
+            rp.trackPublications.set(publication.sid!, publication);
+          }
+        }
 
-      for (const pub of pt.publications) {
-        const publication = new RemoteTrackPublication(pub);
-        rp.trackPublications.set(publication.sid, publication);
-      }
+        FfiClient.instance.on(FfiClientEvent.FfiEvent, this.onFfiEvent);
+        break;
+      case 'error':
+      default:
+        throw new ConnectError(cb.message.value || '');
     }
-
-    FfiClient.instance.on(FfiClientEvent.FfiEvent, this.onFfiEvent);
   }
 
   async disconnect() {
-    if (!this.isConnected || !this.ffiHandle) {
+    if (!this.isConnected) {
       return;
     }
 
@@ -168,7 +155,7 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       message: {
         case: 'disconnect',
         value: {
-          roomHandle: this.ffiHandle.handle,
+          roomHandle: this.ffiHandle?.handle,
         },
       },
     });
@@ -178,27 +165,9 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
   }
 
   private onFfiEvent = (ffiEvent: FfiEvent) => {
-    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 (
+    if (
       ffiEvent.message.case != 'roomEvent' ||
-      ffiEvent.message.value.roomHandle != this.ffiHandle.handle
+      ffiEvent.message.value.roomHandle != this.ffiHandle?.handle
     ) {
       return;
     }
@@ -206,136 +175,125 @@ 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!);
-      this.remoteParticipants.set(participant.identity, participant);
+      this.remoteParticipants.set(participant.identity!, participant);
       this.emit(RoomEvent.ParticipantConnected, participant);
     } else if (ev.case == 'participantDisconnected') {
-      const participant = this.remoteParticipants.get(ev.value.participantIdentity);
-      if (participant) {
-        this.remoteParticipants.delete(participant.identity);
-        this.emit(RoomEvent.ParticipantDisconnected, participant);
-      }
+      const participant = this.remoteParticipants.get(ev.value.participantIdentity!);
+      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);
+      const publication = this.localParticipant!.trackPublications.get(ev.value.trackSid!);
+      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);
-      if (publication) {
-        this.emit(RoomEvent.LocalTrackUnpublished, publication, this.localParticipant);
-      }
+      const publication = this.localParticipant!.trackPublications.get(ev.value.publicationSid!);
+      this.localParticipant!.trackPublications.delete(ev.value.publicationSid!);
+      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!);
+      const publication = this.localParticipant!.trackPublications.get(ev.value.trackSid!);
+      publication!.resolveFirstSubscription();
+      this.emit(RoomEvent.LocalTrackSubscribed, publication!.track!);
     } else if (ev.case == 'trackPublished') {
-      const participant = this.requireRemoteParticipant(ev.value.participantIdentity);
+      const participant = this.remoteParticipants.get(ev.value.participantIdentity!);
       const publication = new RemoteTrackPublication(ev.value.publication!);
-      participant.trackPublications.set(publication.sid, publication);
-      this.emit(RoomEvent.TrackPublished, publication, participant);
+      participant!.trackPublications.set(publication.sid!, publication);
+      this.emit(RoomEvent.TrackPublished, publication, participant!);
     } else if (ev.case == 'trackUnpublished') {
-      const participant = this.requireRemoteParticipant(ev.value.participantIdentity);
-      const publication = participant.trackPublications.get(ev.value.publicationSid);
-      participant.trackPublications.delete(ev.value.publicationSid);
-      if (publication) {
-        this.emit(RoomEvent.TrackUnpublished, publication, participant);
-      }
+      const participant = this.remoteParticipants.get(ev.value.participantIdentity!);
+      const publication = participant!.trackPublications.get(ev.value.publicationSid!);
+      participant!.trackPublications.delete(ev.value.publicationSid!);
+      this.emit(RoomEvent.TrackUnpublished, publication!, participant!);
     } else if (ev.case == 'trackSubscribed') {
-      const ownedTrack = ev.value.track!;
-      const trackInfo = ownedTrack.info!;
-      const { participant, publication } = this.requirePublicationOfRemoteParticipant(
-        ev.value.participantIdentity,
-        trackInfo.sid,
-      );
-      publication.subscribed = true;
-      if (trackInfo.kind == TrackKind.KIND_VIDEO) {
-        publication.track = new RemoteVideoTrack(ownedTrack);
-      } else if (trackInfo.kind == TrackKind.KIND_AUDIO) {
-        publication.track = new RemoteAudioTrack(ownedTrack);
+      const ownedTrack = ev.value.track;
+      const participant = this.remoteParticipants.get(ev.value.participantIdentity!);
+      const publication = participant!.trackPublications.get(ownedTrack!.info!.sid!);
+      publication!.subscribed = true;
+      if (ownedTrack!.info!.kind == TrackKind.KIND_VIDEO) {
+        publication!.track = new RemoteVideoTrack(ownedTrack!);
+      } else if (ownedTrack!.info!.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, publication } = this.requirePublicationOfRemoteParticipant(
-        ev.value.participantIdentity,
-        ev.value.trackSid,
-      );
-      const track = publication.track!;
-      publication.track = undefined;
-      publication.subscribed = false;
-      this.emit(RoomEvent.TrackUnsubscribed, track, publication, participant);
+      const participant = this.remoteParticipants.get(ev.value.participantIdentity!);
+      const publication = participant!.trackPublications.get(ev.value.trackSid!);
+      publication!.track = undefined;
+      publication!.subscribed = false;
+      this.emit(RoomEvent.TrackUnsubscribed, publication!.track!, publication!, participant!);
     } else if (ev.case == 'trackSubscriptionFailed') {
-      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, publication } = this.requirePublicationOfParticipant(
-        ev.value.participantIdentity,
-        ev.value.trackSid,
+      const participant = this.remoteParticipants.get(ev.value.participantIdentity!);
+      this.emit(
+        RoomEvent.TrackSubscriptionFailed,
+        ev.value.trackSid!,
+        participant!,
+        ev.value.error,
       );
-      publication.info.muted = true;
-      if (publication.track) {
-        publication.track.info.muted = true;
+    } else if (ev.case == 'trackMuted') {
+      const participant = this.remoteParticipants.get(ev.value.participantIdentity!);
+      const publication = participant!.trackPublications.get(ev.value.trackSid!);
+      publication!.info!.muted = true;
+      if (publication!.track) {
+        publication!.track.info!.muted = true;
       }
-      this.emit(RoomEvent.TrackMuted, publication, participant);
+      this.emit(RoomEvent.TrackMuted, publication!, participant!);
     } else if (ev.case == 'trackUnmuted') {
-      const { participant, publication } = this.requirePublicationOfParticipant(
-        ev.value.participantIdentity,
-        ev.value.trackSid,
-      );
-      publication.info.muted = false;
-      if (publication.track) {
-        publication.track.info.muted = false;
+      const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity!);
+      const publication = participant!.trackPublications.get(ev.value.trackSid!);
+      publication!.info!.muted = false;
+      if (publication!.track) {
+        publication!.track.info!.muted = false;
       }
-      this.emit(RoomEvent.TrackUnmuted, publication, participant);
+      this.emit(RoomEvent.TrackUnmuted, publication!, participant!);
     } else if (ev.case == 'activeSpeakersChanged') {
       const activeSpeakers = ev.value.participantIdentities.map((identity) =>
-        this.requireParticipantByIdentity(identity),
+        this.retrieveParticipantByIdentity(identity),
+      );
+      this.emit(
+        RoomEvent.ActiveSpeakersChanged,
+        activeSpeakers.map((s) => s!),
       );
-      this.emit(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
     } else if (ev.case == 'roomMetadataChanged') {
-      this.info.metadata = ev.value.metadata;
-      this.emit(RoomEvent.RoomMetadataChanged, this.info.metadata);
+      this.info!.metadata = ev.value.metadata;
+      this.emit(RoomEvent.RoomMetadataChanged, this.info!.metadata!);
     } else if (ev.case == 'participantMetadataChanged') {
-      const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
-      participant.info.metadata = ev.value.metadata;
-      this.emit(RoomEvent.ParticipantMetadataChanged, participant.metadata, participant);
+      const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity!);
+      participant!.info!.metadata = ev.value.metadata;
+      this.emit(RoomEvent.ParticipantMetadataChanged, participant!.metadata, participant!);
     } else if (ev.case == 'participantNameChanged') {
-      const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
-      participant.info.name = ev.value.name;
-      this.emit(RoomEvent.ParticipantNameChanged, participant.name, participant);
+      const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity!);
+      participant!.info!.name = ev.value.name;
+      this.emit(RoomEvent.ParticipantNameChanged, participant!.name!, participant!);
     } else if (ev.case == 'participantAttributesChanged') {
-      const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
-      participant.info.attributes = ev.value.attributes.reduce(
-        (acc, value) => {
-          acc[value.key] = value.value;
-          return acc;
+      const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity!);
+      participant!.info!.attributes = ev.value.attributes.reduce(
+        (obj, item) => {
+          obj[item.key!] = item.value!;
+          return obj;
         },
         {} as Record<string, string>,
       );
       if (Object.keys(ev.value.changedAttributes).length > 0) {
-        const changedAttributes = ev.value.changedAttributes.reduce(
-          (acc, value) => {
-            acc[value.key] = value.value;
-            return acc;
-          },
-          {} as Record<string, string>,
+        this.emit(
+          RoomEvent.ParticipantAttributesChanged,
+          ev.value.changedAttributes.reduce(
+            (obj, item) => {
+              obj[item.key!] = item.value!;
+              return obj;
+            },
+            {} as Record<string, string>,
+          ),
+          participant!,
         );
-        this.emit(RoomEvent.ParticipantAttributesChanged, changedAttributes, participant);
       }
     } else if (ev.case == 'connectionQualityChanged') {
-      const participant = this.requireParticipantByIdentity(ev.value.participantIdentity);
-      this.emit(RoomEvent.ConnectionQualityChanged, ev.value.quality, participant);
+      const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity!);
+      this.emit(RoomEvent.ConnectionQualityChanged, ev.value.quality!, participant!);
     } else if (ev.case == 'chatMessage') {
-      const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity);
+      const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity!);
       const { id, message: messageText, timestamp, editTimestamp, generated } = ev.value.message!;
       const message: ChatMessage = {
-        id,
-        message: messageText,
+        id: id!,
+        message: messageText!,
         timestamp: Number(timestamp),
         editTimestamp: Number(editTimestamp),
         generated,
@@ -343,13 +301,15 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       this.emit(RoomEvent.ChatMessage, message, participant);
     } else if (ev.case == 'dataPacketReceived') {
       // Can be undefined if the data is sent from a Server SDK
-      const participant = this.remoteParticipants.get(ev.value.participantIdentity);
+      const participant = this.remoteParticipants.get(ev.value.participantIdentity!);
       const dataPacket = ev.value.value;
       switch (dataPacket.case) {
         case 'user':
-          const data = dataPacket.value.data!.data!;
-          const buffer = FfiClient.instance.copyBuffer(data.dataPtr, Number(data.dataLen));
-          new FfiHandle(dataPacket.value.data!.handle!.id).dispose();
+          const buffer = FfiClient.instance.copyBuffer(
+            dataPacket.value.data!.data!.dataPtr!,
+            Number(dataPacket.value.data!.data!.dataLen),
+          );
+          new FfiHandle(dataPacket.value.data!.handle!.id!).dispose();
           this.emit(
             RoomEvent.DataReceived,
             buffer,
@@ -360,7 +320,7 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
           break;
         case 'sipDtmf':
           const { code, digit } = dataPacket.value;
-          this.emit(RoomEvent.DtmfReceived, code, digit, participant);
+          this.emit(RoomEvent.DtmfReceived, code!, digit!, participant!);
           break;
         default:
           break;
@@ -371,18 +331,16 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
         this.emit(RoomEvent.EncryptionError, new Error('internal server error'));
       }
     } else if (ev.case == 'connectionStateChanged') {
-      this.connectionState = ev.value.state;
+      this.connectionState = ev.value.state!;
       this.emit(RoomEvent.ConnectionStateChanged, this.connectionState);
       /*} else if (ev.case == 'connected') {
       this.emit(RoomEvent.Connected);*/
     } else if (ev.case == 'disconnected') {
-      this.emit(RoomEvent.Disconnected, ev.value.reason);
+      this.emit(RoomEvent.Disconnected, ev.value.reason!);
     } else if (ev.case == 'reconnecting') {
       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);
     }
   };
 
@@ -431,12 +389,12 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
   }
 
   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;
   }
 }
@@ -477,7 +435,6 @@ 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: (
@@ -492,14 +449,13 @@ 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 {
@@ -517,7 +473,6 @@ export enum RoomEvent {
   TrackUnmuted = 'trackUnmuted',
   ActiveSpeakersChanged = 'activeSpeakersChanged',
   RoomMetadataChanged = 'roomMetadataChanged',
-  RoomSidChanged = 'roomSidChanged',
   ParticipantMetadataChanged = 'participantMetadataChanged',
   ParticipantNameChanged = 'participantNameChanged',
   ParticipantAttributesChanged = 'participantAttributesChanged',

package/src/rpc.ts

@@ -68,7 +68,7 @@ export class RpcError extends Error {
   }
 
   static fromProto(proto: RpcError_Proto) {
-    return new RpcError(proto.code, proto.message, proto.data);
+    return new RpcError(proto.code!, proto.message!, proto.data);
   }
 
   toProto() {

package/src/track.ts

@@ -1,7 +1,6 @@
 // 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 {
@@ -12,39 +11,39 @@ import type {
   TrackInfo,
   TrackKind,
 } from './proto/track_pb.js';
-import { CreateAudioTrackRequestSchema, CreateVideoTrackRequestSchema } from './proto/track_pb.js';
+import { CreateAudioTrackRequest, CreateVideoTrackRequest } from './proto/track_pb.js';
 import type { VideoSource } from './video_source.js';
 
 export abstract class Track {
   /** @internal */
-  info: TrackInfo;
+  info?: TrackInfo;
 
   /** @internal */
   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 {
-    return this.info.sid;
+  get sid(): string | undefined {
+    return this.info?.sid;
   }
 
-  get name(): string {
-    return this.info.name;
+  get name(): string | undefined {
+    return this.info?.name;
   }
 
-  get kind(): TrackKind {
-    return this.info.kind;
+  get kind(): TrackKind | undefined {
+    return this.info?.kind;
   }
 
-  get stream_state(): StreamState {
-    return this.info.streamState;
+  get stream_state(): StreamState | undefined {
+    return this.info?.streamState;
   }
 
-  get muted(): boolean {
-    return this.info.muted;
+  get muted(): boolean | undefined {
+    return this.info?.muted;
   }
 }
 
@@ -54,7 +53,7 @@ export class LocalAudioTrack extends Track {
   }
 
   static createAudioTrack(name: string, source: AudioSource): LocalAudioTrack {
-    const req = create(CreateAudioTrackRequestSchema, {
+    const req = new CreateAudioTrackRequest({
       name: name,
       sourceHandle: source.ffiHandle.handle,
     });
@@ -73,7 +72,7 @@ export class LocalVideoTrack extends Track {
   }
 
   static createVideoTrack(name: string, source: VideoSource): LocalVideoTrack {
-    const req = create(CreateVideoTrackRequestSchema, {
+    const req = new CreateVideoTrackRequest({
       name: name,
       sourceHandle: source.ffiHandle.handle,
     });