@casual-simulation/aux-vm-browser 3.4.6-alpha.14668890889 → 3.5.0-alpha.15117651144

package/managers/LivekitManager.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { asyncResult, hasValue, ON_ROOM_JOINED, ON_ROOM_LEAVE, ON_ROOM_OPTIONS_CHANGED, ON_ROOM_REMOTE_JOINED, ON_ROOM_REMOTE_LEAVE, ON_ROOM_SPEAKERS_CHANGED, ON_ROOM_STREAMING, ON_ROOM_STREAM_LOST, ON_ROOM_TRACK_SUBSCRIBED, ON_ROOM_TRACK_UNSUBSCRIBED, } from '@casual-simulation/aux-common';
 import { Subject } from 'rxjs';
 /**
@@ -52,187 +43,183 @@ export class LivekitManager {
         this._addressToTrack = null;
         this._trackToAddress = null;
     }
-    _requestMediaPermissions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Request audio and video permission (required)
+    async _requestMediaPermissions() {
+        // Request audio and video permission (required)
+        try {
+            await navigator.mediaDevices.getUserMedia({
+                video: true,
+                audio: true,
+            });
+            console.log('[LivekitManager] Media permissions granted.');
+        }
+        catch (error) {
+            console.error('[LivekitManager] Media permissions denied:', error);
+            throw new Error('Media permissions are required to join the room.');
+        }
+    }
+    async joinRoom(join) {
+        try {
+            await this._requestMediaPermissions();
+            this._livekit = await import('livekit-client');
+            const room = new this._livekit.Room({
+                adaptiveStream: false,
+                dynacast: true,
+                ...join.options,
+            });
+            room.on(this._livekit.RoomEvent.TrackSubscribed, this._onTrackSubscribed(room))
+                .on(this._livekit.RoomEvent.TrackUnsubscribed, this._onTrackUnsubscribed(room))
+                .on(this._livekit.RoomEvent.Disconnected, this._onDisconnected(room))
+                .on(this._livekit.RoomEvent.Reconnected, this._onReconnected(room))
+                .on(this._livekit.RoomEvent.LocalTrackPublished, this._onLocalTrackPublished(room))
+                .on(this._livekit.RoomEvent.LocalTrackUnpublished, this._onLocalTrackUnpublished(room))
+                .on(this._livekit.RoomEvent.TrackMuted, this._onTrackMuted(room))
+                .on(this._livekit.RoomEvent.TrackUnmuted, this._onTrackUnmuted(room))
+                .on(this._livekit.RoomEvent.ActiveSpeakersChanged, this._onActiveSpeakersChanged(room))
+                .on(this._livekit.RoomEvent.ParticipantConnected, this._onParticipantConnected(room))
+                .on(this._livekit.RoomEvent.ParticipantDisconnected, this._onParticipantDisconnected(room));
+            await room.connect(join.url, join.token, {});
             try {
-                yield navigator.mediaDevices.getUserMedia({
+                await this._setRoomOptions(room, {
                     video: true,
                     audio: true,
+                    ...join.options,
                 });
-                console.log('[LivekitManager] Media permissions granted.');
-            }
-            catch (error) {
-                console.error('[LivekitManager] Media permissions denied:', error);
-                throw new Error('Media permissions are required to join the room.');
-            }
-        });
-    }
-    joinRoom(join) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this._requestMediaPermissions();
-                this._livekit = yield import('livekit-client');
-                const room = new this._livekit.Room(Object.assign({ adaptiveStream: false, dynacast: true }, join.options));
-                room.on(this._livekit.RoomEvent.TrackSubscribed, this._onTrackSubscribed(room))
-                    .on(this._livekit.RoomEvent.TrackUnsubscribed, this._onTrackUnsubscribed(room))
-                    .on(this._livekit.RoomEvent.Disconnected, this._onDisconnected(room))
-                    .on(this._livekit.RoomEvent.Reconnected, this._onReconnected(room))
-                    .on(this._livekit.RoomEvent.LocalTrackPublished, this._onLocalTrackPublished(room))
-                    .on(this._livekit.RoomEvent.LocalTrackUnpublished, this._onLocalTrackUnpublished(room))
-                    .on(this._livekit.RoomEvent.TrackMuted, this._onTrackMuted(room))
-                    .on(this._livekit.RoomEvent.TrackUnmuted, this._onTrackUnmuted(room))
-                    .on(this._livekit.RoomEvent.ActiveSpeakersChanged, this._onActiveSpeakersChanged(room))
-                    .on(this._livekit.RoomEvent.ParticipantConnected, this._onParticipantConnected(room))
-                    .on(this._livekit.RoomEvent.ParticipantDisconnected, this._onParticipantDisconnected(room));
-                yield room.connect(join.url, join.token, {});
-                try {
-                    yield this._setRoomOptions(room, Object.assign({ video: true, audio: true }, join.options));
-                }
-                catch (err) {
-                    console.warn('[LivekitManager] Unable to set room options:', err);
-                }
-                this._rooms.push(room);
-                const options = this._getRoomOptions(room);
-                join.resolve(options);
-                let actions = [
-                    {
-                        eventName: ON_ROOM_JOINED,
-                        bots: null,
-                        arg: { roomName: room.name, options },
-                    },
-                    {
-                        eventName: ON_ROOM_STREAMING,
-                        bots: null,
-                        arg: { roomName: room.name, options },
-                    },
-                ];
-                // Send initial ON_ROOM_REMOTE_JOINED events
-                for (let participant of room.remoteParticipants.values()) {
-                    actions.push({
-                        eventName: ON_ROOM_REMOTE_JOINED,
-                        bots: null,
-                        arg: {
-                            roomName: room.name,
-                            remoteId: participant.identity,
-                        },
-                    });
-                }
-                this._helper.transaction(...this._helper.actions(actions));
             }
             catch (err) {
-                join.reject('server_error', err.toString());
+                console.warn('[LivekitManager] Unable to set room options:', err);
+            }
+            this._rooms.push(room);
+            const options = this._getRoomOptions(room);
+            join.resolve(options);
+            let actions = [
+                {
+                    eventName: ON_ROOM_JOINED,
+                    bots: null,
+                    arg: { roomName: room.name, options },
+                },
+                {
+                    eventName: ON_ROOM_STREAMING,
+                    bots: null,
+                    arg: { roomName: room.name, options },
+                },
+            ];
+            // Send initial ON_ROOM_REMOTE_JOINED events
+            for (let participant of room.remoteParticipants.values()) {
+                actions.push({
+                    eventName: ON_ROOM_REMOTE_JOINED,
+                    bots: null,
+                    arg: {
+                        roomName: room.name,
+                        remoteId: participant.identity,
+                    },
+                });
             }
-        });
+            this._helper.transaction(...this._helper.actions(actions));
+        }
+        catch (err) {
+            join.reject('server_error', err.toString());
+        }
     }
-    leaveRoom(leave) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const index = this._rooms.findIndex((r) => r.name === leave.roomName);
-                let room;
-                let actions = [];
-                if (index >= 0) {
-                    room = this._rooms[index];
-                    this._rooms.splice(index, 1);
-                    if (room) {
-                        // Send ON_ROOM_REMOTE_LEAVE events
-                        for (let participant of room.remoteParticipants.values()) {
-                            actions.push({
-                                eventName: ON_ROOM_REMOTE_LEAVE,
-                                bots: null,
-                                arg: {
-                                    roomName: room.name,
-                                    remoteId: participant.identity,
-                                },
-                            });
-                        }
-                        room.disconnect(true);
-                    }
-                }
-                leave.resolve();
+    async leaveRoom(leave) {
+        try {
+            const index = this._rooms.findIndex((r) => r.name === leave.roomName);
+            let room;
+            let actions = [];
+            if (index >= 0) {
+                room = this._rooms[index];
+                this._rooms.splice(index, 1);
                 if (room) {
-                    actions.push({
-                        eventName: ON_ROOM_STREAM_LOST,
-                        bots: null,
-                        arg: { roomName: leave.roomName },
-                    }, {
-                        eventName: ON_ROOM_LEAVE,
-                        bots: null,
-                        arg: { roomName: leave.roomName },
-                    });
-                    this._helper.transaction(...this._helper.actions(actions));
-                }
-            }
-            catch (err) {
-                leave.reject('error', err.toString());
-            }
-        });
-    }
-    setRoomOptions(setRoomOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const room = this._rooms.find((r) => r.name === setRoomOptions.roomName);
-                if (!room || !this._livekit) {
-                    setRoomOptions.reject('room_not_found', 'The specified room was not found.');
-                    return;
-                }
-                const changed = yield this._setRoomOptions(room, setRoomOptions.options);
-                const options = this._getRoomOptions(room);
-                let rejected = false;
-                for (let key in setRoomOptions.options) {
-                    const targetValue = setRoomOptions.options[key];
-                    const currentValue = options[key];
-                    if (targetValue !== currentValue) {
-                        setRoomOptions.reject('error', `Unable to set "${key}" to ${targetValue}`);
-                        rejected = true;
+                    // Send ON_ROOM_REMOTE_LEAVE events
+                    for (let participant of room.remoteParticipants.values()) {
+                        actions.push({
+                            eventName: ON_ROOM_REMOTE_LEAVE,
+                            bots: null,
+                            arg: {
+                                roomName: room.name,
+                                remoteId: participant.identity,
+                            },
+                        });
                     }
-                }
-                if (!rejected) {
-                    setRoomOptions.resolve(options);
-                }
-                if (changed) {
-                    this._helper.action(ON_ROOM_OPTIONS_CHANGED, null, {
-                        roomName: room.name,
-                        options,
-                    });
+                    room.disconnect(true);
                 }
             }
-            catch (err) {
-                setRoomOptions.reject('error', err.toString());
+            leave.resolve();
+            if (room) {
+                actions.push({
+                    eventName: ON_ROOM_STREAM_LOST,
+                    bots: null,
+                    arg: { roomName: leave.roomName },
+                }, {
+                    eventName: ON_ROOM_LEAVE,
+                    bots: null,
+                    arg: { roomName: leave.roomName },
+                });
+                this._helper.transaction(...this._helper.actions(actions));
             }
-        });
+        }
+        catch (err) {
+            leave.reject('error', err.toString());
+        }
     }
-    _setRoomOptions(room, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let promises = [];
-            if ('video' in options) {
-                promises.push(room.localParticipant.setCameraEnabled(!!options.video));
+    async setRoomOptions(setRoomOptions) {
+        try {
+            const room = this._rooms.find((r) => r.name === setRoomOptions.roomName);
+            if (!room || !this._livekit) {
+                setRoomOptions.reject('room_not_found', 'The specified room was not found.');
+                return;
+            }
+            const changed = await this._setRoomOptions(room, setRoomOptions.options);
+            const options = this._getRoomOptions(room);
+            let rejected = false;
+            for (let key in setRoomOptions.options) {
+                const targetValue = setRoomOptions.options[key];
+                const currentValue = options[key];
+                if (targetValue !== currentValue) {
+                    setRoomOptions.reject('error', `Unable to set "${key}" to ${targetValue}`);
+                    rejected = true;
+                }
             }
-            if ('audio' in options) {
-                promises.push(room.localParticipant.setMicrophoneEnabled(!!options.audio));
+            if (!rejected) {
+                setRoomOptions.resolve(options);
             }
-            if ('screen' in options) {
-                promises.push(room.localParticipant.setScreenShareEnabled(!!options.screen));
+            if (changed) {
+                this._helper.action(ON_ROOM_OPTIONS_CHANGED, null, {
+                    roomName: room.name,
+                    options,
+                });
             }
-            const results = yield Promise.allSettled(promises);
-            return results.some((r) => r.status === 'fulfilled');
-        });
+        }
+        catch (err) {
+            setRoomOptions.reject('error', err.toString());
+        }
     }
-    getRoomOptions(getRoomOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const room = this._rooms.find((r) => r.name === getRoomOptions.roomName);
-                if (!room) {
-                    getRoomOptions.reject('room_not_found', 'The specified room was not found.');
-                    return;
-                }
-                const options = this._getRoomOptions(room);
-                getRoomOptions.resolve(options);
-            }
-            catch (err) {
-                getRoomOptions.reject('error', err.toString());
-            }
-        });
+    async _setRoomOptions(room, options) {
+        let promises = [];
+        if ('video' in options) {
+            promises.push(room.localParticipant.setCameraEnabled(!!options.video));
+        }
+        if ('audio' in options) {
+            promises.push(room.localParticipant.setMicrophoneEnabled(!!options.audio));
+        }
+        if ('screen' in options) {
+            promises.push(room.localParticipant.setScreenShareEnabled(!!options.screen));
+        }
+        const results = await Promise.allSettled(promises);
+        return results.some((r) => r.status === 'fulfilled');
+    }
+    async getRoomOptions(getRoomOptions) {
+        try {
+            const room = this._rooms.find((r) => r.name === getRoomOptions.roomName);
+            if (!room) {
+                getRoomOptions.reject('room_not_found', 'The specified room was not found.');
+                return;
+            }
+            const options = this._getRoomOptions(room);
+            getRoomOptions.resolve(options);
+        }
+        catch (err) {
+            getRoomOptions.reject('error', err.toString());
+        }
     }
     _getRoomOptions(room) {
         return this._getParticipantOptions(room.localParticipant);
@@ -275,130 +262,126 @@ export class LivekitManager {
             }
         }
     }
-    _getRoomTrackOptions(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const room = this._rooms.find((r) => r.name === event.roomName);
-                if (!room || !this._livekit) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: false,
-                        errorCode: 'room_not_found',
-                        errorMessage: 'The specified room was not found.',
-                        roomName: event.roomName,
-                    }));
-                    return;
-                }
-                const pub = this._addressToPublication.get(event.address);
-                const participant = this._addressToParticipant.get(event.address);
-                if (!pub || !participant) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: false,
-                        errorCode: 'track_not_found',
-                        errorMessage: 'The specified track was not found.',
-                        roomName: event.roomName,
-                        address: event.address,
-                    }));
-                    return;
-                }
-                const options = this._getTrackOptions(pub, participant);
+    async _getRoomTrackOptions(event) {
+        try {
+            const room = this._rooms.find((r) => r.name === event.roomName);
+            if (!room || !this._livekit) {
                 this._helper.transaction(asyncResult(event.taskId, {
-                    success: true,
-                    roomName: room.name,
+                    success: false,
+                    errorCode: 'room_not_found',
+                    errorMessage: 'The specified room was not found.',
+                    roomName: event.roomName,
+                }));
+                return;
+            }
+            const pub = this._addressToPublication.get(event.address);
+            const participant = this._addressToParticipant.get(event.address);
+            if (!pub || !participant) {
+                this._helper.transaction(asyncResult(event.taskId, {
+                    success: false,
+                    errorCode: 'track_not_found',
+                    errorMessage: 'The specified track was not found.',
+                    roomName: event.roomName,
                     address: event.address,
-                    options,
                 }));
+                return;
             }
-            catch (err) {
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: false,
-                        errorCode: 'error',
-                        errorMessage: err.toString(),
-                        roomName: event.roomName,
-                        address: event.address,
-                    }));
-                }
+            const options = this._getTrackOptions(pub, participant);
+            this._helper.transaction(asyncResult(event.taskId, {
+                success: true,
+                roomName: room.name,
+                address: event.address,
+                options,
+            }));
+        }
+        catch (err) {
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, {
+                    success: false,
+                    errorCode: 'error',
+                    errorMessage: err.toString(),
+                    roomName: event.roomName,
+                    address: event.address,
+                }));
             }
-        });
+        }
     }
-    _setRoomTrackOptions(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const room = this._rooms.find((r) => r.name === event.roomName);
-                if (!room || !this._livekit) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: false,
-                        errorCode: 'room_not_found',
-                        errorMessage: 'The specified room was not found.',
-                        roomName: event.roomName,
-                    }));
-                    return;
+    async _setRoomTrackOptions(event) {
+        try {
+            const room = this._rooms.find((r) => r.name === event.roomName);
+            if (!room || !this._livekit) {
+                this._helper.transaction(asyncResult(event.taskId, {
+                    success: false,
+                    errorCode: 'room_not_found',
+                    errorMessage: 'The specified room was not found.',
+                    roomName: event.roomName,
+                }));
+                return;
+            }
+            const pub = this._addressToPublication.get(event.address);
+            const participant = this._addressToParticipant.get(event.address);
+            if (!pub || !participant) {
+                this._helper.transaction(asyncResult(event.taskId, {
+                    success: false,
+                    errorCode: 'track_not_found',
+                    errorMessage: 'The specified track was not found.',
+                    roomName: event.roomName,
+                    address: event.address,
+                }));
+                return;
+            }
+            let promises = [];
+            if ('muted' in event.options) {
+                if (pub instanceof this._livekit.LocalTrackPublication) {
+                    if (event.options.muted) {
+                        promises.push(pub.mute().then(() => { }));
+                    }
+                    else {
+                        promises.push(pub.unmute().then(() => { }));
+                    }
                 }
-                const pub = this._addressToPublication.get(event.address);
-                const participant = this._addressToParticipant.get(event.address);
-                if (!pub || !participant) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: false,
-                        errorCode: 'track_not_found',
-                        errorMessage: 'The specified track was not found.',
-                        roomName: event.roomName,
-                        address: event.address,
-                    }));
-                    return;
+                else if (pub instanceof this._livekit.RemoteTrackPublication) {
+                    pub.setEnabled(!event.options.muted);
                 }
-                let promises = [];
-                if ('muted' in event.options) {
-                    if (pub instanceof this._livekit.LocalTrackPublication) {
-                        if (event.options.muted) {
-                            promises.push(pub.mute().then(() => { }));
-                        }
-                        else {
-                            promises.push(pub.unmute().then(() => { }));
-                        }
+            }
+            if ('videoQuality' in event.options) {
+                if (pub instanceof this._livekit.RemoteTrackPublication) {
+                    let quality = this._livekit.VideoQuality.HIGH;
+                    if (event.options.videoQuality === 'medium') {
+                        quality = this._livekit.VideoQuality.MEDIUM;
                     }
-                    else if (pub instanceof this._livekit.RemoteTrackPublication) {
-                        pub.setEnabled(!event.options.muted);
+                    else if (event.options.videoQuality === 'low') {
+                        quality = this._livekit.VideoQuality.LOW;
                     }
-                }
-                if ('videoQuality' in event.options) {
-                    if (pub instanceof this._livekit.RemoteTrackPublication) {
-                        let quality = this._livekit.VideoQuality.HIGH;
-                        if (event.options.videoQuality === 'medium') {
-                            quality = this._livekit.VideoQuality.MEDIUM;
-                        }
-                        else if (event.options.videoQuality === 'low') {
-                            quality = this._livekit.VideoQuality.LOW;
-                        }
-                        else if (event.options.videoQuality === 'high') {
-                            quality = this._livekit.VideoQuality.HIGH;
-                        }
-                        else if (event.options.videoQuality === 'off') {
-                            pub.setEnabled(false);
-                        }
-                        pub.setVideoQuality(quality);
+                    else if (event.options.videoQuality === 'high') {
+                        quality = this._livekit.VideoQuality.HIGH;
                     }
+                    else if (event.options.videoQuality === 'off') {
+                        pub.setEnabled(false);
+                    }
+                    pub.setVideoQuality(quality);
                 }
-                yield Promise.allSettled(promises);
-                const options = this._getTrackOptions(pub, participant);
+            }
+            await Promise.allSettled(promises);
+            const options = this._getTrackOptions(pub, participant);
+            this._helper.transaction(asyncResult(event.taskId, {
+                success: true,
+                roomName: room.name,
+                address: event.address,
+                options,
+            }));
+        }
+        catch (err) {
+            if (hasValue(event.taskId)) {
                 this._helper.transaction(asyncResult(event.taskId, {
-                    success: true,
-                    roomName: room.name,
+                    success: false,
+                    errorCode: 'error',
+                    errorMessage: err.toString(),
+                    roomName: event.roomName,
                     address: event.address,
-                    options,
                 }));
             }
-            catch (err) {
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: false,
-                        errorCode: 'error',
-                        errorMessage: err.toString(),
-                        roomName: event.roomName,
-                        address: event.address,
-                    }));
-                }
-            }
-        });
+        }
     }
     _findRemoteParticipant(room, identity) {
         for (let p of room.remoteParticipants.values()) {
@@ -408,51 +391,53 @@ export class LivekitManager {
         }
         return null;
     }
-    _getRoomRemoteOptions(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const room = this._rooms.find((r) => r.name === event.roomName);
-                if (!room || !this._livekit) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: false,
-                        errorCode: 'room_not_found',
-                        errorMessage: 'The specified room was not found.',
-                        roomName: event.roomName,
-                    }));
-                    return;
-                }
-                const participant = this._findRemoteParticipant(room, event.remoteId);
-                if (!participant) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: false,
-                        errorCode: 'remote_not_found',
-                        errorMessage: 'The specified remote was not found.',
-                        roomName: event.roomName,
-                        remoteId: event.remoteId,
-                    }));
-                    return;
-                }
-                const basicOptions = this._getParticipantOptions(participant);
-                const options = Object.assign(Object.assign({}, basicOptions), { audioLevel: participant.audioLevel, connectionQuality: participant.connectionQuality });
+    async _getRoomRemoteOptions(event) {
+        try {
+            const room = this._rooms.find((r) => r.name === event.roomName);
+            if (!room || !this._livekit) {
                 this._helper.transaction(asyncResult(event.taskId, {
-                    success: true,
-                    roomName: room.name,
-                    remoteId: event.remoteId,
-                    options,
+                    success: false,
+                    errorCode: 'room_not_found',
+                    errorMessage: 'The specified room was not found.',
+                    roomName: event.roomName,
                 }));
+                return;
             }
-            catch (err) {
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: false,
-                        errorCode: 'error',
-                        errorMessage: err.toString(),
-                        roomName: event.roomName,
-                        remoteId: event.remoteId,
-                    }));
-                }
+            const participant = this._findRemoteParticipant(room, event.remoteId);
+            if (!participant) {
+                this._helper.transaction(asyncResult(event.taskId, {
+                    success: false,
+                    errorCode: 'remote_not_found',
+                    errorMessage: 'The specified remote was not found.',
+                    roomName: event.roomName,
+                    remoteId: event.remoteId,
+                }));
+                return;
+            }
+            const basicOptions = this._getParticipantOptions(participant);
+            const options = {
+                ...basicOptions,
+                audioLevel: participant.audioLevel,
+                connectionQuality: participant.connectionQuality,
+            };
+            this._helper.transaction(asyncResult(event.taskId, {
+                success: true,
+                roomName: room.name,
+                remoteId: event.remoteId,
+                options,
+            }));
+        }
+        catch (err) {
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, {
+                    success: false,
+                    errorCode: 'error',
+                    errorMessage: err.toString(),
+                    roomName: event.roomName,
+                    remoteId: event.remoteId,
+                }));
             }
-        });
+        }
     }
     /**
      * Gets the media stream that is referenced by the given address.
@@ -527,7 +512,11 @@ export class LivekitManager {
         };
     }
     _trackArg(roomName, pub, participant, address, track) {
-        return Object.assign({ roomName: roomName, address: address }, this._getTrackOptions(pub, participant, track));
+        return {
+            roomName: roomName,
+            address: address,
+            ...this._getTrackOptions(pub, participant, track),
+        };
     }
     _getTrackOptions(pub, participant, t) {
         const track = t !== null && t !== void 0 ? t : pub.track;
@@ -540,10 +529,17 @@ export class LivekitManager {
             source: track.source,
         };
         if (pub.kind === this._livekit.Track.Kind.Video) {
-            return Object.assign(Object.assign({}, common), { dimensions: pub.dimensions, aspectRatio: pub.dimensions.width / pub.dimensions.height, videoQuality: this._getTrackQuality(pub) });
+            return {
+                ...common,
+                dimensions: pub.dimensions,
+                aspectRatio: pub.dimensions.width / pub.dimensions.height,
+                videoQuality: this._getTrackQuality(pub),
+            };
         }
         else {
-            return Object.assign({}, common);
+            return {
+                ...common,
+            };
         }
     }
     _onDisconnected(room) {