@livekit/rtc-node 0.3.0 → 0.4.1

package/src/nodejs.rs

@@ -16,8 +16,8 @@ use prost::Message;
 use std::sync::Arc;
 
 #[napi(ts_args_type = "callback: (data: Uint8Array) => void, captureLogs: boolean")]
-fn livekit_initialize(cb: JsFunction, capture_logs: bool) {
-    let tsfn: ThreadsafeFunction<proto::FfiEvent, ErrorStrategy::Fatal> = cb
+fn livekit_initialize(env: Env, cb: JsFunction, capture_logs: bool) {
+    let mut tsfn: ThreadsafeFunction<proto::FfiEvent, ErrorStrategy::Fatal> = cb
         .create_threadsafe_function(0, |ctx: ThreadSafeCallContext<proto::FfiEvent>| {
             let data = ctx.value.encode_to_vec();
             let buf = Uint8Array::new(data);
@@ -25,6 +25,8 @@ fn livekit_initialize(cb: JsFunction, capture_logs: bool) {
         })
         .unwrap();
 
+    let _ = tsfn.unref(&env);
+
     FFI_SERVER.setup(server::FfiConfig {
         callback_fn: Arc::new(move |event| {
             let status = tsfn.call(event, ThreadsafeFunctionCallMode::NonBlocking);

package/src/participant.ts

@@ -1,34 +1,32 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-
-import { FfiClient, FfiClientEvent, FfiHandle, FfiRequest } from './ffi_client.js';
-import { ParticipantInfo, OwnedParticipant } from './proto/participant_pb.js';
-import {
-  DataPacketKind,
+import { FfiClient, FfiHandle } from './ffi_client.js';
+import type { OwnedParticipant, ParticipantInfo } from './proto/participant_pb.js';
+import type {
   PublishDataCallback,
-  PublishDataRequest,
   PublishDataResponse,
   PublishTrackCallback,
-  PublishTrackRequest,
   PublishTrackResponse,
   TrackPublishOptions,
   UnpublishTrackCallback,
-  UnpublishTrackRequest,
   UnpublishTrackResponse,
   UpdateLocalMetadataCallback,
-  UpdateLocalMetadataRequest,
   UpdateLocalMetadataResponse,
   UpdateLocalNameCallback,
-  UpdateLocalNameRequest,
   UpdateLocalNameResponse,
 } from './proto/room_pb.js';
 import {
-  LocalTrackPublication,
-  RemoteTrackPublication,
-  TrackPublication,
-} from './track_publication.js';
-import { LocalTrack } from './track.js';
+  DataPacketKind,
+  PublishDataRequest,
+  PublishTrackRequest,
+  UnpublishTrackRequest,
+  UpdateLocalMetadataRequest,
+  UpdateLocalNameRequest,
+} from './proto/room_pb.js';
+import type { LocalTrack } from './track.js';
+import type { RemoteTrackPublication, TrackPublication } from './track_publication.js';
+import { LocalTrackPublication } from './track_publication.js';
 
 export abstract class Participant {
   /** @internal */
@@ -81,7 +79,7 @@ export class LocalParticipant extends Participant {
   trackPublications: Map<string, LocalTrackPublication> = new Map();
 
   async publishData(data: Uint8Array, options: DataPublishOptions) {
-    let req = new PublishDataRequest({
+    const req = new PublishDataRequest({
       localParticipantHandle: this.ffi_handle.handle,
       dataPtr: FfiClient.instance.retrievePtr(data),
       dataLen: BigInt(data.byteLength),
@@ -97,11 +95,11 @@ export class LocalParticipant extends Participant {
       req.destinationSids = sids;
     }
 
-    let res = FfiClient.instance.request<PublishDataResponse>({
+    const res = FfiClient.instance.request<PublishDataResponse>({
       message: { case: 'publishData', value: req },
     });
 
-    let cb = await FfiClient.instance.waitFor<PublishDataCallback>((ev) => {
+    const cb = await FfiClient.instance.waitFor<PublishDataCallback>((ev) => {
       return ev.message.case == 'publishData' && ev.message.value.asyncId == res.asyncId;
     });
 
@@ -111,12 +109,12 @@ export class LocalParticipant extends Participant {
   }
 
   async updateMetadata(metadata: string) {
-    let req = new UpdateLocalMetadataRequest({
+    const req = new UpdateLocalMetadataRequest({
       localParticipantHandle: this.ffi_handle.handle,
       metadata: metadata,
     });
 
-    let res = FfiClient.instance.request<UpdateLocalMetadataResponse>({
+    const res = FfiClient.instance.request<UpdateLocalMetadataResponse>({
       message: { case: 'updateLocalMetadata', value: req },
     });
 
@@ -126,12 +124,12 @@ export class LocalParticipant extends Participant {
   }
 
   async updateName(name: string) {
-    let req = new UpdateLocalNameRequest({
+    const req = new UpdateLocalNameRequest({
       localParticipantHandle: this.ffi_handle.handle,
       name: name,
     });
 
-    let res = FfiClient.instance.request<UpdateLocalNameResponse>({
+    const res = FfiClient.instance.request<UpdateLocalNameResponse>({
       message: { case: 'updateLocalName', value: req },
     });
 
@@ -144,21 +142,21 @@ export class LocalParticipant extends Participant {
     track: LocalTrack,
     options: TrackPublishOptions,
   ): Promise<LocalTrackPublication> {
-    let req = new PublishTrackRequest({
+    const req = new PublishTrackRequest({
       localParticipantHandle: this.ffi_handle.handle,
       trackHandle: track.ffi_handle.handle,
       options: options,
     });
 
-    let res = FfiClient.instance.request<PublishTrackResponse>({
+    const res = FfiClient.instance.request<PublishTrackResponse>({
       message: { case: 'publishTrack', value: req },
     });
 
-    let cb = await FfiClient.instance.waitFor<PublishTrackCallback>((ev) => {
+    const cb = await FfiClient.instance.waitFor<PublishTrackCallback>((ev) => {
       return ev.message.case == 'publishTrack' && ev.message.value.asyncId == res.asyncId;
     });
 
-    let track_publication = new LocalTrackPublication(cb.publication);
+    const track_publication = new LocalTrackPublication(cb.publication);
     track_publication.track = track;
     this.trackPublications.set(track_publication.sid, track_publication);
 
@@ -166,12 +164,12 @@ export class LocalParticipant extends Participant {
   }
 
   async unpublishTrack(trackSid: string) {
-    let req = new UnpublishTrackRequest({
+    const req = new UnpublishTrackRequest({
       localParticipantHandle: this.ffi_handle.handle,
       trackSid: trackSid,
     });
 
-    let res = FfiClient.instance.request<UnpublishTrackResponse>({
+    const res = FfiClient.instance.request<UnpublishTrackResponse>({
       message: { case: 'unpublishTrack', value: req },
     });
 
@@ -179,7 +177,7 @@ export class LocalParticipant extends Participant {
       return ev.message.case == 'unpublishTrack' && ev.message.value.asyncId == res.asyncId;
     });
 
-    let pub = this.trackPublications.get(trackSid);
+    const pub = this.trackPublications.get(trackSid);
     pub.track = undefined;
     this.trackPublications.delete(trackSid);
   }

package/src/room.ts

@@ -1,35 +1,36 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-
-import { FfiClient, FfiClientEvent, FfiHandle } from './ffi_client.js';
 import EventEmitter from 'events';
-import TypedEmitter from 'typed-emitter';
-import { FfiEvent } from './proto/ffi_pb.js';
-import { LocalParticipant, Participant, RemoteParticipant } from './participant.js';
-import {
+import type TypedEmitter from 'typed-emitter';
+import type { E2EEOptions } from './e2ee.js';
+import { E2EEManager } from './e2ee.js';
+import { FfiClient, FfiClientEvent, FfiHandle } from './ffi_client.js';
+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,
-  ConnectRequest,
   ConnectResponse,
   ConnectionQuality,
-  ConnectionState,
-  ContinualGatheringPolicy,
   DataPacketKind,
   DisconnectResponse,
   IceServer,
-  IceTransportType,
   RoomInfo,
 } from './proto/room_pb.js';
-import { E2EEManager, E2EEOptions, defaultE2EEOptions } from './e2ee.js';
-import { OwnedParticipant } from './proto/participant_pb.js';
 import {
-  LocalTrackPublication,
-  RemoteTrackPublication,
-  TrackPublication,
-} from './track_publication.js';
-import { LocalTrack, RemoteAudioTrack, RemoteTrack, RemoteVideoTrack } from './track.js';
+  ConnectRequest,
+  ConnectionState,
+  ContinualGatheringPolicy,
+  IceTransportType,
+} from './proto/room_pb.js';
 import { TrackKind } from './proto/track_pb.js';
-import { EncryptionState } from './proto/e2ee_pb.js';
+import type { RemoteTrack } from './track.js';
+import { RemoteAudioTrack, RemoteVideoTrack } from './track.js';
+import type { LocalTrackPublication, TrackPublication } from './track_publication.js';
+import { RemoteTrackPublication } from './track_publication.js';
 
 export interface RtcConfiguration {
   iceTransportType: IceTransportType;
@@ -90,7 +91,7 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
   async connect(url: string, token: string, opts?: RoomOptions) {
     const options = { ...defaultRoomOptions, ...opts };
 
-    let req = new ConnectRequest({
+    const req = new ConnectRequest({
       url: url,
       token: token,
       options: {
@@ -108,14 +109,14 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       },
     });
 
-    let res = FfiClient.instance.request<ConnectResponse>({
+    const res = FfiClient.instance.request<ConnectResponse>({
       message: {
         case: 'connect',
         value: req,
       },
     });
 
-    let cb = await FfiClient.instance.waitFor<ConnectCallback>((ev: FfiEvent) => {
+    const cb = await FfiClient.instance.waitFor<ConnectCallback>((ev: FfiEvent) => {
       return ev.message.case == 'connect' && ev.message.value.asyncId == res.asyncId;
     });
 
@@ -130,11 +131,11 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     this.connectionState = ConnectionState.CONN_CONNECTED;
     this.localParticipant = new LocalParticipant(cb.localParticipant);
 
-    for (let pt of cb.participants) {
-      let rp = this.createRemoteParticipant(pt.participant);
+    for (const pt of cb.participants) {
+      const rp = this.createRemoteParticipant(pt.participant);
 
-      for (let pub of pt.publications) {
-        let publication = new RemoteTrackPublication(pub);
+      for (const pub of pt.publications) {
+        const publication = new RemoteTrackPublication(pub);
         rp.trackPublications.set(publication.sid, publication);
       }
     }
@@ -155,6 +156,9 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
         },
       },
     });
+
+    FfiClient.instance.removeAllListeners();
+    this.removeAllListeners();
   }
 
   private onFfiEvent = (ffiEvent: FfiEvent) => {
@@ -165,36 +169,36 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       return;
     }
 
-    let ev = ffiEvent.message.value.message;
+    const ev = ffiEvent.message.value.message;
     if (ev.case == 'participantConnected') {
-      let 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') {
-      let participant = this.getRemoteParticipantBySid(ev.value.participantSid);
+      const participant = this.getRemoteParticipantBySid(ev.value.participantSid);
       this.remoteParticipants.delete(participant.identity);
       this.emit(RoomEvent.ParticipantDisconnected, participant);
     } else if (ev.case == 'localTrackPublished') {
-      let publication = this.localParticipant.trackPublications.get(ev.value.trackSid);
-      this.emit(RoomEvent.LocalTrackPublished, publication, publication.track);
+      const publication = this.localParticipant.trackPublications.get(ev.value.trackSid);
+      this.emit(RoomEvent.LocalTrackPublished, publication, this.localParticipant);
     } else if (ev.case == 'localTrackUnpublished') {
-      let publication = this.localParticipant.trackPublications.get(ev.value.publicationSid);
+      const publication = this.localParticipant.trackPublications.get(ev.value.publicationSid);
       this.localParticipant.trackPublications.delete(ev.value.publicationSid);
-      this.emit(RoomEvent.LocalTrackUnpublished, publication);
+      this.emit(RoomEvent.LocalTrackUnpublished, publication, this.localParticipant);
     } else if (ev.case == 'trackPublished') {
-      let participant = this.getRemoteParticipantBySid(ev.value.participantSid);
-      let publication = new RemoteTrackPublication(ev.value.publication);
+      const participant = this.getRemoteParticipantBySid(ev.value.participantSid);
+      const publication = new RemoteTrackPublication(ev.value.publication);
       participant.trackPublications.set(publication.sid, publication);
       this.emit(RoomEvent.TrackPublished, publication, participant);
     } else if (ev.case == 'trackUnpublished') {
-      let participant = this.getRemoteParticipantBySid(ev.value.participantSid);
-      let publication = participant.trackPublications.get(ev.value.publicationSid);
+      const participant = this.getRemoteParticipantBySid(ev.value.participantSid);
+      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') {
-      let ownedTrack = ev.value.track;
-      let participant = this.getRemoteParticipantBySid(ev.value.participantSid);
-      let publication = participant.trackPublications.get(ownedTrack.info.sid);
+      const ownedTrack = ev.value.track;
+      const participant = this.getRemoteParticipantBySid(ev.value.participantSid);
+      const publication = participant.trackPublications.get(ownedTrack.info.sid);
       publication.subscribed = true;
       if (ownedTrack.info.kind == TrackKind.KIND_VIDEO) {
         publication.track = new RemoteVideoTrack(ownedTrack);
@@ -204,70 +208,64 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
 
       this.emit(RoomEvent.TrackSubscribed, publication.track, publication, participant);
     } else if (ev.case == 'trackUnsubscribed') {
-      let participant = this.getRemoteParticipantBySid(ev.value.participantSid);
-      let publication = participant.trackPublications.get(ev.value.trackSid);
+      const participant = this.getRemoteParticipantBySid(ev.value.participantSid);
+      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') {
-      let participant = this.getRemoteParticipantBySid(ev.value.participantSid);
-      this.emit(RoomEvent.TrackSubscriptionFailed, participant, ev.value.trackSid, ev.value.error);
+      const participant = this.getRemoteParticipantBySid(ev.value.participantSid);
+      this.emit(RoomEvent.TrackSubscriptionFailed, ev.value.trackSid, participant, ev.value.error);
     } else if (ev.case == 'trackMuted') {
-      let participant = this.retrieveParticipant(ev.value.participantSid);
-      let publication = participant.trackPublications.get(ev.value.trackSid);
+      const participant = this.retrieveParticipant(ev.value.participantSid);
+      const publication = participant.trackPublications.get(ev.value.trackSid);
       publication.info.muted = true;
       if (publication.track) {
         publication.track.info.muted = true;
       }
-      this.emit(RoomEvent.TrackMuted, participant, publication);
+      this.emit(RoomEvent.TrackMuted, publication, participant);
     } else if (ev.case == 'trackUnmuted') {
-      let participant = this.retrieveParticipant(ev.value.participantSid);
-      let publication = participant.trackPublications.get(ev.value.trackSid);
+      const participant = this.retrieveParticipant(ev.value.participantSid);
+      const publication = participant.trackPublications.get(ev.value.trackSid);
       publication.info.muted = false;
       if (publication.track) {
         publication.track.info.muted = false;
       }
-      this.emit(RoomEvent.TrackUnmuted, participant, publication);
+      this.emit(RoomEvent.TrackUnmuted, publication, participant);
     } else if (ev.case == 'activeSpeakersChanged') {
-      let activeSpeakers = ev.value.participantSids.map((sid) =>
+      const activeSpeakers = ev.value.participantSids.map((sid) =>
         this.getRemoteParticipantBySid(sid),
       );
       this.emit(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
     } else if (ev.case == 'roomMetadataChanged') {
-      let oldMetadata = this.info.metadata;
       this.info.metadata = ev.value.metadata;
-      this.emit(RoomEvent.RoomMetadataChanged, oldMetadata, this.info.metadata);
+      this.emit(RoomEvent.RoomMetadataChanged, this.info.metadata);
     } else if (ev.case == 'participantMetadataChanged') {
-      let participant = this.retrieveParticipant(ev.value.participantSid);
-      let oldMetadata = participant.metadata;
+      const participant = this.retrieveParticipant(ev.value.participantSid);
       participant.info.metadata = ev.value.metadata;
-      this.emit(
-        RoomEvent.ParticipantMetadataChanged,
-        participant,
-        oldMetadata,
-        participant.metadata,
-      );
+      this.emit(RoomEvent.ParticipantMetadataChanged, participant.metadata, participant);
     } else if (ev.case == 'participantNameChanged') {
-      let participant = this.retrieveParticipant(ev.value.participantSid);
-      let oldName = participant.name;
+      const participant = this.retrieveParticipant(ev.value.participantSid);
       participant.info.name = ev.value.name;
-      this.emit(RoomEvent.ParticipantNameChanged, participant, oldName, participant.name);
+      this.emit(RoomEvent.ParticipantNameChanged, participant.name, participant);
     } else if (ev.case == 'connectionQualityChanged') {
-      let participant = this.retrieveParticipant(ev.value.participantSid);
-      this.emit(RoomEvent.ConnectionQualityChanged, participant, ev.value.quality);
+      const participant = this.retrieveParticipant(ev.value.participantSid);
+      this.emit(RoomEvent.ConnectionQualityChanged, ev.value.quality, participant);
     } else if (ev.case == 'dataReceived') {
       // Can be undefined if the data is sent from a Server SDK
-      let participant = this.getRemoteParticipantBySid(ev.value.participantSid);
-      let info = ev.value.data;
-      let buffer = FfiClient.instance.copyBuffer(info.data.dataPtr, Number(info.data.dataLen));
+      const participant = this.getRemoteParticipantBySid(ev.value.participantSid);
+      const info = ev.value.data;
+      const buffer = FfiClient.instance.copyBuffer(info.data.dataPtr, Number(info.data.dataLen));
       new FfiHandle(info.handle.id).dispose();
-      this.emit(RoomEvent.DataReceived, buffer, ev.value.kind, participant);
+      this.emit(RoomEvent.DataReceived, buffer, participant, ev.value.kind, ev.value.topic);
     } else if (ev.case == 'e2eeStateChanged') {
-      let participant = this.retrieveParticipant(ev.value.participantSid);
-      this.emit(RoomEvent.E2EEStateChanged, participant, ev.value.state);
+      if (ev.value.state == EncryptionState.INTERNAL_ERROR) {
+        // throw generic error until Rust SDK is updated to supply the error alongside INTERNAL_ERROR
+        this.emit(RoomEvent.EncryptionError, new Error('internal server error'));
+      }
     } else if (ev.case == 'connectionStateChanged') {
       this.connectionState = ev.value.state;
-      this.emit(RoomEvent.ConenctionStateChanged, this.connectionState);
+      this.emit(RoomEvent.ConnectionStateChanged, this.connectionState);
       /*} else if (ev.case == 'connected') {
       this.emit(RoomEvent.Connected);*/
     } else if (ev.case == 'disconnected') {
@@ -311,8 +309,11 @@ export class ConnectError extends Error {
 export type RoomCallbacks = {
   participantConnected: (participant: RemoteParticipant) => void;
   participantDisconnected: (participant: RemoteParticipant) => void;
-  localTrackPublished: (publication: LocalTrackPublication, track: LocalTrack) => void;
-  localTrackUnpublished: (publication: LocalTrackPublication) => void;
+  localTrackPublished: (publication: LocalTrackPublication, participant: LocalParticipant) => void;
+  localTrackUnpublished: (
+    publication: LocalTrackPublication,
+    participant: LocalParticipant,
+  ) => void;
   trackPublished: (publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
   trackUnpublished: (publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
   trackSubscribed: (
@@ -326,26 +327,27 @@ export type RoomCallbacks = {
     participant: RemoteParticipant,
   ) => void;
   trackSubscriptionFailed: (
+    trackSid: string,
     participant: RemoteParticipant,
-    publicationSid: string,
-    error: string,
+    reason?: string,
   ) => void;
-  trackMuted: (participant: Participant, publication: TrackPublication) => void;
-  trackUnmuted: (participant: Participant, publication: TrackPublication) => void;
-  activeSpeakersChanged: (speakers: RemoteParticipant[]) => void;
-  roomMetadataChanged: (oldMetadata: string, metadata: string) => void;
-  participantMetadataChanged: (
-    participant: Participant,
-    oldMetadata: string,
-    metadata: string,
+  trackMuted: (publication: TrackPublication, participant: Participant) => void;
+  trackUnmuted: (publication: TrackPublication, participant: Participant) => void;
+  activeSpeakersChanged: (speakers: Participant[]) => void;
+  roomMetadataChanged: (metadata: string) => void;
+  participantMetadataChanged: (metadata: string | undefined, participant: Participant) => void;
+  participantNameChanged: (name: string, participant: Participant) => void;
+  connectionQualityChanged: (quality: ConnectionQuality, participant: Participant) => void;
+  dataReceived: (
+    payload: Uint8Array,
+    participant?: RemoteParticipant,
+    kind?: DataPacketKind,
+    topic?: string,
   ) => void;
-  participantNameChanged: (participant: Participant, oldName: string, name: string) => void;
-  connectionQualityChanged: (participant: Participant, quality: ConnectionQuality) => void;
-  dataReceived: (data: Uint8Array, kind: DataPacketKind, participant?: RemoteParticipant) => void;
-  e2eeStateChanged: (participant: Participant, state: EncryptionState) => void;
+  encryptionError: (error: Error) => void;
   connectionStateChanged: (state: ConnectionState) => void;
   connected: () => void;
-  disconnected: () => void;
+  disconnected: (reason?: string) => void;
   reconnecting: () => void;
   reconnected: () => void;
 };
@@ -368,8 +370,8 @@ export enum RoomEvent {
   ParticipantNameChanged = 'participantNameChanged',
   ConnectionQualityChanged = 'connectionQualityChanged',
   DataReceived = 'dataReceived',
-  E2EEStateChanged = 'e2eeStateChanged',
-  ConenctionStateChanged = 'connectionStateChanged',
+  EncryptionError = 'encryptionError',
+  ConnectionStateChanged = 'connectionStateChanged',
   Connected = 'connected',
   Disconnected = 'disconnected',
   Reconnecting = 'reconnecting',

package/src/track.ts

@@ -1,20 +1,18 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-
-import { AudioSource } from './audio_source.js';
-import { FfiClient, FfiHandle, FfiRequest } from './ffi_client.js';
-import {
-  CreateAudioTrackRequest,
+import type { AudioSource } from './audio_source.js';
+import { FfiClient, FfiHandle } from './ffi_client.js';
+import type {
   CreateAudioTrackResponse,
-  CreateVideoTrackRequest,
   CreateVideoTrackResponse,
   OwnedTrack,
   StreamState,
   TrackInfo,
   TrackKind,
 } from './proto/track_pb.js';
-import { VideoSource } from './video_source.js';
+import { CreateAudioTrackRequest, CreateVideoTrackRequest } from './proto/track_pb.js';
+import type { VideoSource } from './video_source.js';
 
 export abstract class Track {
   /** @internal */
@@ -55,12 +53,12 @@ export class LocalAudioTrack extends Track {
   }
 
   static createAudioTrack(name: string, source: AudioSource): LocalAudioTrack {
-    let req = new CreateAudioTrackRequest({
+    const req = new CreateAudioTrackRequest({
       name: name,
       sourceHandle: source.ffiHandle.handle,
     });
 
-    let res = FfiClient.instance.request<CreateAudioTrackResponse>({
+    const res = FfiClient.instance.request<CreateAudioTrackResponse>({
       message: { case: 'createAudioTrack', value: req },
     });
 
@@ -74,12 +72,12 @@ export class LocalVideoTrack extends Track {
   }
 
   static createVideoTrack(name: string, source: VideoSource): LocalVideoTrack {
-    let req = new CreateVideoTrackRequest({
+    const req = new CreateVideoTrackRequest({
       name: name,
       sourceHandle: source.ffiHandle.handle,
     });
 
-    let res = FfiClient.instance.request<CreateVideoTrackResponse>({
+    const res = FfiClient.instance.request<CreateVideoTrackResponse>({
       message: { case: 'createVideoTrack', value: req },
     });
 

package/src/track_publication.ts

@@ -1,18 +1,18 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-
-import { FfiClient, FfiRequest } from './ffi_client.js';
+import { FfiClient } from './ffi_client.js';
 import { FfiHandle } from './napi/native.js';
-import { EncryptionType } from './proto/e2ee_pb.js';
-import { SetSubscribedRequest, SetSubscribedResponse } from './proto/room_pb.js';
-import {
+import type { EncryptionType } from './proto/e2ee_pb.js';
+import type { SetSubscribedResponse } from './proto/room_pb.js';
+import { SetSubscribedRequest } from './proto/room_pb.js';
+import type {
   OwnedTrackPublication,
   TrackKind,
   TrackPublicationInfo,
   TrackSource,
 } from './proto/track_pb.js';
-import { Track } from './track.js';
+import type { Track } from './track.js';
 
 export abstract class TrackPublication {
   /** @internal */
@@ -82,7 +82,7 @@ export class RemoteTrackPublication extends TrackPublication {
   }
 
   setSubscribed(subscribed: boolean) {
-    let req = new SetSubscribedRequest({
+    const req = new SetSubscribedRequest({
       subscribe: subscribed,
       publicationHandle: this.ffiHandle.handle,
     });

package/src/video_frame.ts

@@ -1,14 +1,12 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-
-import { FfiClient, FfiHandle, FfiRequest } from './ffi_client.js';
+import { FfiClient, FfiRequest } from './ffi_client.js';
+import type { OwnedVideoBuffer, VideoConvertResponse } from './proto/video_frame_pb.js';
 import {
-  OwnedVideoBuffer,
   VideoBufferInfo,
   VideoBufferInfo_ComponentInfo,
   VideoBufferType,
-  VideoConvertResponse,
 } from './proto/video_frame_pb.js';
 
 export class VideoFrame {
@@ -17,12 +15,7 @@ export class VideoFrame {
   height: number;
   type: VideoBufferType;
 
-  constructor(
-    data: Uint8Array,
-    width: number,
-    height: number,
-    type: VideoBufferType,
-  ) {
+  constructor(data: Uint8Array, width: number, height: number, type: VideoBufferType) {
     this.data = data;
     this.width = width;
     this.height = height;
@@ -31,7 +24,7 @@ export class VideoFrame {
 
   /** @internal */
   get dataPtr(): bigint {
-    return FfiClient.instance.retrievePtr(new Uint8Array(this.data.buffer))
+    return FfiClient.instance.retrievePtr(new Uint8Array(this.data.buffer));
   }
 
   /** @internal */
@@ -60,7 +53,7 @@ export class VideoFrame {
 
   /** @internal */
   static fromOwnedInfo(owned: OwnedVideoBuffer): VideoFrame {
-    let info = owned.info;
+    const info = owned.info;
     return new VideoFrame(
       FfiClient.instance.copyBuffer(
         info.dataPtr,
@@ -73,7 +66,7 @@ export class VideoFrame {
   }
 
   getPlane(planeNth: number): Uint8Array | void {
-    const planeInfos = getPlaneInfos(this.dataPtr, this.type, this.width, this.height)
+    const planeInfos = getPlaneInfos(this.dataPtr, this.type, this.width, this.height);
     if (planeNth >= planeInfos.length) return;
 
     const planeInfo = planeInfos[planeNth];
@@ -91,12 +84,12 @@ export class VideoFrame {
         },
       },
     });
-    const resp = FfiClient.instance.request<VideoConvertResponse>(req)
+    const resp = FfiClient.instance.request<VideoConvertResponse>(req);
     if (resp.error) {
-      throw resp.error
+      throw resp.error;
     }
 
-    return VideoFrame.fromOwnedInfo(resp.buffer)
+    return VideoFrame.fromOwnedInfo(resp.buffer);
   }
 }