@microsoft/live-share-media 2.0.0-internal.18 → 2.0.0-internal.19

package/bin/esm/LiveMediaSessionCoordinator.js

@@ -2,15 +2,6 @@
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the Microsoft Live Share SDK License.
  */
-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 { LiveTelemetryLogger, LiveDataObjectInitializeState, LiveDataObjectInitializeNotNeededError, LiveDataObjectNotInitializedError, } from "@microsoft/live-share";
 import { LiveEventScope, LiveEventTarget, LiveObjectSynchronizer, isErrorLike, } from "@microsoft/live-share/internal";
 import { GroupCoordinatorState, GroupCoordinatorStateEvents, } from "./internals/GroupCoordinatorState.js";
@@ -25,109 +16,128 @@ import { TypedEventEmitter } from "@fluid-internal/client-utils";
  * in sync with the group.
  */
 export class LiveMediaSessionCoordinator extends TypedEventEmitter {
+    _id;
+    _runtime;
+    _liveRuntime;
+    _logger;
+    _getPlayerState;
+    _positionUpdateInterval = new PriorityTimeInterval(2000, 
+    // Scale by function
+    () => {
+        const audience = this._liveRuntime.audience;
+        if (!audience)
+            return 1;
+        // As the audience size gets bigger, we relax the update interval, since more variance is expected
+        const count = audience.getMembers().size;
+        return 1 + count / 5;
+    });
+    _maxPlaybackDrift = new PriorityTimeInterval(1500, // Scale by function
+    () => {
+        const audience = this._liveRuntime.audience;
+        if (!audience)
+            return 1;
+        // As the audience size gets bigger, we relax the playback drift, since more variance is expected
+        const count = audience.getMembers().size;
+        return 1 + count / 25;
+    });
+    _lastWaitPoint;
+    initializeState = LiveDataObjectInitializeState.needed;
+    // Broadcast events
+    _playEvent;
+    _pauseEvent;
+    _seekToEvent;
+    _rateChangeEvent;
+    _setTrackEvent;
+    _setTrackDataEvent;
+    _positionUpdateEvent;
+    // Synchronizer does not play a significant role in LiveMediaSession beyond being able to
+    // use "connect" events to replace old "joined" events when sending position data to new clients.
+    _synchronizer;
+    // Distributed state
+    _groupState;
     /**
      * @hidden
      * Applications shouldn't directly create new coordinator instances.
      */
     constructor(id, runtime, liveRuntime, getPlayerState) {
         super();
-        this._positionUpdateInterval = new PriorityTimeInterval(2000, 
-        // Scale by function
-        () => {
-            const audience = this._liveRuntime.audience;
-            if (!audience)
-                return 1;
-            // As the audience size gets bigger, we relax the update interval, since more variance is expected
-            const count = audience.getMembers().size;
-            return 1 + count / 5;
-        });
-        this._maxPlaybackDrift = new PriorityTimeInterval(1500, // Scale by function
-        () => {
-            const audience = this._liveRuntime.audience;
-            if (!audience)
-                return 1;
-            // As the audience size gets bigger, we relax the playback drift, since more variance is expected
-            const count = audience.getMembers().size;
-            return 1 + count / 25;
-        });
-        this.initializeState = LiveDataObjectInitializeState.needed;
-        /**
-         * Controls whether or not the local client is allowed to instruct the group to play or pause.
-         *
-         * @remarks
-         * This flag largely meant to influence decisions made by the coordinator and can be used by
-         * the UI to determine what controls should be shown to the user. It does not provide any
-         * security in itself.
-         *
-         * If your app is running in a semi-trusted environment where only some clients are allowed
-         * to play/pause media, you should use "role based verification" to enforce those policies.
-         */
-        this.canPlayPause = true;
-        /**
-         * Controls whether or not the local client is allowed to seek the group to a new playback
-         * position.
-         *
-         * @remarks
-         * This flag largely meant to influence decisions made by the coordinator and can be used by
-         * the UI to determine what controls should be shown to the user. It does not provide any
-         * security in itself.
-         *
-         * If your app is running in a semi-trusted environment where only some clients are allowed
-         * to change the playback position, you should use "role based verification" to enforce those policies.
-         */
-        this.canSeek = true;
-        /**
-         * Controls whether or not the local client is allowed to change tracks.
-         *
-         * @remarks
-         * This flag largely meant to influence decisions made by the coordinator and can be used by
-         * the UI to determine what controls should be shown to the user. It does not provide any
-         * security in itself.
-         *
-         * If your app is running in a semi-trusted environment where only some clients are allowed
-         * to change tracks, you should use "role based verification" to enforce those policies.
-         */
-        this.canSetTrack = true;
-        /**
-         * Controls whether or not the local client is allowed to change the tracks custom data object.
-         *
-         * @remarks
-         * This flag largely meant to influence decisions made by the coordinator and can be used by
-         * the UI to determine what controls should be shown to the user. It does not provide any
-         * security in itself.
-         *
-         * If your app is running in a semi-trusted environment where only some clients are allowed
-         * to change the tracks data object, you should use "role based verification" to enforce those
-         * policies.
-         */
-        this.canSetTrackData = true;
-        /**
-         * Controls whether or not the local client is allowed to change the playback rate.
-         *
-         * @remarks
-         * This flag largely meant to influence decisions made by the coordinator and can be used by
-         * the UI to determine what controls should be shown to the user. It does not provide any
-         * security in itself.
-         *
-         * If your app is running in a semi-trusted environment where only some clients are allowed
-         * to change the tracks data object, you should use "role based verification" to enforce those
-         * policies.
-         */
-        this.canSetPlaybackRate = true;
-        /**
-         * Controls whether or not the local client is allowed to send position updates to the group.
-         *
-         * @remarks
-         * This flag largely meant to limit the number of signals sent to the group for performance reasons.
-         * It does not provide any security in itself.
-         */
-        this.canSendPositionUpdates = true;
         this._id = id;
         this._runtime = runtime;
         this._liveRuntime = liveRuntime;
         this._logger = new LiveTelemetryLogger(runtime, liveRuntime);
         this._getPlayerState = getPlayerState;
     }
+    /**
+     * Controls whether or not the local client is allowed to instruct the group to play or pause.
+     *
+     * @remarks
+     * This flag largely meant to influence decisions made by the coordinator and can be used by
+     * the UI to determine what controls should be shown to the user. It does not provide any
+     * security in itself.
+     *
+     * If your app is running in a semi-trusted environment where only some clients are allowed
+     * to play/pause media, you should use "role based verification" to enforce those policies.
+     */
+    canPlayPause = true;
+    /**
+     * Controls whether or not the local client is allowed to seek the group to a new playback
+     * position.
+     *
+     * @remarks
+     * This flag largely meant to influence decisions made by the coordinator and can be used by
+     * the UI to determine what controls should be shown to the user. It does not provide any
+     * security in itself.
+     *
+     * If your app is running in a semi-trusted environment where only some clients are allowed
+     * to change the playback position, you should use "role based verification" to enforce those policies.
+     */
+    canSeek = true;
+    /**
+     * Controls whether or not the local client is allowed to change tracks.
+     *
+     * @remarks
+     * This flag largely meant to influence decisions made by the coordinator and can be used by
+     * the UI to determine what controls should be shown to the user. It does not provide any
+     * security in itself.
+     *
+     * If your app is running in a semi-trusted environment where only some clients are allowed
+     * to change tracks, you should use "role based verification" to enforce those policies.
+     */
+    canSetTrack = true;
+    /**
+     * Controls whether or not the local client is allowed to change the tracks custom data object.
+     *
+     * @remarks
+     * This flag largely meant to influence decisions made by the coordinator and can be used by
+     * the UI to determine what controls should be shown to the user. It does not provide any
+     * security in itself.
+     *
+     * If your app is running in a semi-trusted environment where only some clients are allowed
+     * to change the tracks data object, you should use "role based verification" to enforce those
+     * policies.
+     */
+    canSetTrackData = true;
+    /**
+     * Controls whether or not the local client is allowed to change the playback rate.
+     *
+     * @remarks
+     * This flag largely meant to influence decisions made by the coordinator and can be used by
+     * the UI to determine what controls should be shown to the user. It does not provide any
+     * security in itself.
+     *
+     * If your app is running in a semi-trusted environment where only some clients are allowed
+     * to change the tracks data object, you should use "role based verification" to enforce those
+     * policies.
+     */
+    canSetPlaybackRate = true;
+    /**
+     * Controls whether or not the local client is allowed to send position updates to the group.
+     *
+     * @remarks
+     * This flag largely meant to limit the number of signals sent to the group for performance reasons.
+     * It does not provide any security in itself.
+     */
+    canSendPositionUpdates = true;
     /**
      * Returns true if the local client is in a suspended state.
      */
@@ -202,25 +212,22 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter {
      *
      * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    play() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:play", "play", this.initializeState);
-            TrackMetadataNotSetError.assert(!!((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.current.metadata), "LiveMediaSessionCoordinator:play", "play");
-            ActionBlockedError.assert(this.canPlayPause, "LiveMediaSessionCoordinator:play", "play", "canPlayPause");
-            // Get projected position
-            const position = this.getPlayerPosition();
-            // Send transport command
-            this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.PlayCalled, null, { position: position });
-            yield this._playEvent.sendEvent({
-                track: this._groupState.playbackTrack.current,
-                position: position,
-            });
-            if (this.canSendPositionUpdates) {
-                // User has taken initiative to send event, give priority for sending position updates
-                this._positionUpdateInterval.hasPriority = true;
-            }
+    async play() {
+        LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:play", "play", this.initializeState);
+        TrackMetadataNotSetError.assert(!!this._groupState?.playbackTrack.current.metadata, "LiveMediaSessionCoordinator:play", "play");
+        ActionBlockedError.assert(this.canPlayPause, "LiveMediaSessionCoordinator:play", "play", "canPlayPause");
+        // Get projected position
+        const position = this.getPlayerPosition();
+        // Send transport command
+        this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.PlayCalled, null, { position: position });
+        await this._playEvent.sendEvent({
+            track: this._groupState.playbackTrack.current,
+            position: position,
         });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
     /**
      * Instructs the group to pause the current track.
@@ -231,25 +238,22 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter {
      *
      * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    pause() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:pause", "pause", this.initializeState);
-            TrackMetadataNotSetError.assert(!!((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.current.metadata), "LiveMediaSessionCoordinator:pause", "pause");
-            ActionBlockedError.assert(this.canPlayPause, "LiveMediaSessionCoordinator:pause", "pause", "canPlayPause");
-            // Get projected position
-            const position = this.getPlayerPosition();
-            // Send transport command
-            this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.PauseCalled, null, { position: position });
-            yield this._pauseEvent.sendEvent({
-                track: this._groupState.playbackTrack.current,
-                position: position,
-            });
-            if (this.canSendPositionUpdates) {
-                // User has taken initiative to send event, give priority for sending position updates
-                this._positionUpdateInterval.hasPriority = true;
-            }
+    async pause() {
+        LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:pause", "pause", this.initializeState);
+        TrackMetadataNotSetError.assert(!!this._groupState?.playbackTrack.current.metadata, "LiveMediaSessionCoordinator:pause", "pause");
+        ActionBlockedError.assert(this.canPlayPause, "LiveMediaSessionCoordinator:pause", "pause", "canPlayPause");
+        // Get projected position
+        const position = this.getPlayerPosition();
+        // Send transport command
+        this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.PauseCalled, null, { position: position });
+        await this._pauseEvent.sendEvent({
+            track: this._groupState.playbackTrack.current,
+            position: position,
         });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
     /**
      * Instructs the group to seek to a new position within the current track.
@@ -260,29 +264,26 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter {
      * @param time Playback position in seconds to seek to.
      * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    seekTo(time) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:seekTo", "seekTo", this.initializeState);
-            TrackMetadataNotSetError.assert(!!((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.current.metadata), "LiveMediaSessionCoordinator:seekTo", "seekTo");
-            ActionBlockedError.assert(this.canSeek, "LiveMediaSessionCoordinator:seekTo", "seekTo", "canSeek");
-            // Send transport command
-            this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.SeekToCalled, null, { position: time });
-            try {
-                yield this._seekToEvent.sendEvent({
-                    track: this._groupState.playbackTrack.current,
-                    position: time,
-                });
-                if (this.canSendPositionUpdates) {
-                    // User has taken initiative to send event, give priority for sending position updates
-                    this._positionUpdateInterval.hasPriority = true;
-                }
-            }
-            catch (err) {
-                yield this._groupState.syncLocalMediaSession();
-                throw err;
+    async seekTo(time) {
+        LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:seekTo", "seekTo", this.initializeState);
+        TrackMetadataNotSetError.assert(!!this._groupState?.playbackTrack.current.metadata, "LiveMediaSessionCoordinator:seekTo", "seekTo");
+        ActionBlockedError.assert(this.canSeek, "LiveMediaSessionCoordinator:seekTo", "seekTo", "canSeek");
+        // Send transport command
+        this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.SeekToCalled, null, { position: time });
+        try {
+            await this._seekToEvent.sendEvent({
+                track: this._groupState.playbackTrack.current,
+                position: time,
+            });
+            if (this.canSendPositionUpdates) {
+                // User has taken initiative to send event, give priority for sending position updates
+                this._positionUpdateInterval.hasPriority = true;
             }
-        });
+        }
+        catch (err) {
+            await this._groupState.syncLocalMediaSession();
+            throw err;
+        }
     }
     /**
      * Sets the playback rate for everyone in the session.
@@ -292,17 +293,15 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter {
      * @throws
      * Throws an exception if the session/coordinator hasn't been initialized or {@link canSetPlaybackRate} is false.
      */
-    setPlaybackRate(playbackRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:setPlaybackRate", "setPlaybackRate", this.initializeState);
-            ActionBlockedError.assert(this.canSetPlaybackRate, "LiveMediaSessionCoordinator:setPlaybackRate", "setPlaybackRate", "canSetPlaybackRate");
-            this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.SetPlaybackRateCalled, null, { playbackRate });
-            yield this._rateChangeEvent.sendEvent({ playbackRate });
-            if (this.canSendPositionUpdates) {
-                // User has taken initiative to send event, give priority for sending position updates
-                this._positionUpdateInterval.hasPriority = true;
-            }
-        });
+    async setPlaybackRate(playbackRate) {
+        LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:setPlaybackRate", "setPlaybackRate", this.initializeState);
+        ActionBlockedError.assert(this.canSetPlaybackRate, "LiveMediaSessionCoordinator:setPlaybackRate", "setPlaybackRate", "canSetPlaybackRate");
+        this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.SetPlaybackRateCalled, null, { playbackRate });
+        await this._rateChangeEvent.sendEvent({ playbackRate });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
     /**
      * Instructs the group to load a new track.
@@ -314,21 +313,19 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter {
      * @param waitPoints Optional. List of static wait points to configure for the track.  Dynamic wait points can be added via the `beginSuspension()` call.
      * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    setTrack(metadata, waitPoints) {
-        return __awaiter(this, void 0, void 0, function* () {
-            LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:setTrack", "setTrack", this.initializeState);
-            ActionBlockedError.assert(this.canSetTrack, "LiveMediaSessionCoordinator:setTrack", "setTrack", "canSetTrack");
-            // Send transport command
-            this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.SetTrackCalled);
-            yield this._setTrackEvent.sendEvent({
-                metadata: metadata,
-                waitPoints: waitPoints || [],
-            });
-            if (this.canSendPositionUpdates) {
-                // User has taken initiative to send event, give priority for sending position updates
-                this._positionUpdateInterval.hasPriority = true;
-            }
+    async setTrack(metadata, waitPoints) {
+        LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:setTrack", "setTrack", this.initializeState);
+        ActionBlockedError.assert(this.canSetTrack, "LiveMediaSessionCoordinator:setTrack", "setTrack", "canSetTrack");
+        // Send transport command
+        this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.SetTrackCalled);
+        await this._setTrackEvent.sendEvent({
+            metadata: metadata,
+            waitPoints: waitPoints || [],
         });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
     /**
      * Updates the track data object for the current track.
@@ -342,20 +339,18 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter {
      * @param data New data object to sync with the group. This value will be synchronized using a last writer wins strategy.
      * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    setTrackData(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:setTrackData", "setTrackData", this.initializeState);
-            ActionBlockedError.assert(this.canSetTrackData, "LiveMediaSessionCoordinator:setTrackData", "setTrackData", "canSetTrackData");
-            // Send transport command
-            this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.SetTrackDataCalled);
-            yield this._setTrackDataEvent.sendEvent({
-                data: data,
-            });
-            if (this.canSendPositionUpdates) {
-                // User has taken initiative to send event, give priority for sending position updates
-                this._positionUpdateInterval.hasPriority = true;
-            }
+    async setTrackData(data) {
+        LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:setTrackData", "setTrackData", this.initializeState);
+        ActionBlockedError.assert(this.canSetTrackData, "LiveMediaSessionCoordinator:setTrackData", "setTrackData", "canSetTrackData");
+        // Send transport command
+        this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.SetTrackDataCalled);
+        await this._setTrackDataEvent.sendEvent({
+            data: data,
         });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
     /**
      * Begins a new local suspension.
@@ -382,9 +377,8 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter {
      * @returns The suspension object. Call `end()` on the returned suspension to end the suspension.
      */
     beginSuspension(waitPoint) {
-        var _a;
         LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:beginSuspension", "beginSuspension", this.initializeState);
-        TrackMetadataNotSetError.assert(!!((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.current.metadata), "LiveMediaSessionCoordinator:beginSuspension", "beginSuspension");
+        TrackMetadataNotSetError.assert(!!this._groupState?.playbackTrack.current.metadata, "LiveMediaSessionCoordinator:beginSuspension", "beginSuspension");
         // Tell group state that suspension is started
         if (waitPoint) {
             this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.BeginSuspensionAndWait, null, {
@@ -400,7 +394,6 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter {
         }
         // Return new suspension object
         return new LiveMediaSessionCoordinatorSuspension(waitPoint, (time) => {
-            var _a, _b;
             if (waitPoint) {
                 this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.EndSuspensionAndWait, null, {
                     position: waitPoint.position,
@@ -412,8 +405,8 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter {
             }
             this._groupState.endSuspension(time == undefined);
             if (time != undefined &&
-                !((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.isSuspended) &&
-                !((_b = this._groupState) === null || _b === void 0 ? void 0 : _b.isWaiting)) {
+                !this._groupState?.isSuspended &&
+                !this._groupState?.isWaiting) {
                 // Seek to new position
                 this.seekTo(Math.max(time, 0.0));
             }
@@ -430,55 +423,52 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter {
      * @hidden
      * Called by MediaSession to start coordinator.
      */
-    initialize(acceptTransportChangesFrom) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            LiveDataObjectInitializeNotNeededError.assert("LiveMediaSessionCoordinator:initialize", this.initializeState);
-            this.initializeState = LiveDataObjectInitializeState.pending;
-            try {
-                // Create children
-                yield this.createChildren(acceptTransportChangesFrom);
-            }
-            catch (error) {
-                this.initializeState = LiveDataObjectInitializeState.needed;
-                throw error;
-            }
-            this.initializeState = LiveDataObjectInitializeState.succeeded;
-            try {
-                // start needs to happen after setting initializedState to "succeeded"
-                yield ((_a = this._synchronizer) === null || _a === void 0 ? void 0 : _a.start({
-                    initialState: undefined,
-                    updateState: (evt, sender, local) => __awaiter(this, void 0, void 0, function* () { return false; }),
-                    getLocalUserCanSend: (connecting) => __awaiter(this, void 0, void 0, function* () { return true; }),
-                    enableBackgroundUpdates: false,
-                }));
-            }
-            catch (error) {
-                // not a fatal error for LiveMediaSession, only used for "connect" event to send new clients position updates.
-                this._logger.sendErrorEvent(TelemetryEvents.SessionCoordinator
-                    .LiveObjectSynchronizerStartError, error);
-            }
-        });
+    async initialize(acceptTransportChangesFrom) {
+        LiveDataObjectInitializeNotNeededError.assert("LiveMediaSessionCoordinator:initialize", this.initializeState);
+        this.initializeState = LiveDataObjectInitializeState.pending;
+        try {
+            // Create children
+            await this.createChildren(acceptTransportChangesFrom);
+        }
+        catch (error) {
+            this.initializeState = LiveDataObjectInitializeState.needed;
+            throw error;
+        }
+        this.initializeState = LiveDataObjectInitializeState.succeeded;
+        try {
+            // start needs to happen after setting initializedState to "succeeded"
+            await this._synchronizer?.start({
+                initialState: undefined,
+                updateState: async (evt, sender, local) => false,
+                getLocalUserCanSend: async (connecting) => true,
+                enableBackgroundUpdates: false,
+            });
+        }
+        catch (error) {
+            // not a fatal error for LiveMediaSession, only used for "connect" event to send new clients position updates.
+            this._logger.sendErrorEvent(TelemetryEvents.SessionCoordinator
+                .LiveObjectSynchronizerStartError, error);
+        }
     }
     /**
      * @hidden
      * Called by the MediaSession to detect if a wait point has been hit.
      */
     findNextWaitPoint() {
-        var _a;
-        return (((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.findNextWaitPoint(this._lastWaitPoint)) || null);
+        return (this._groupState?.playbackTrack.findNextWaitPoint(this._lastWaitPoint) || null);
     }
     /**
      * @hidden
      * Called by MediaSession to trigger the sending of a position update.
      */
     sendPositionUpdate(state, targetClientId) {
-        var _a, _b;
         LiveDataObjectNotInitializedError.assert("LiveMediaSessionCoordinator:sendPositionUpdate", "sendPositionUpdate", this.initializeState);
         if (this.canSendPositionUpdates) {
             // Send position update event
             const evt = this._groupState.createPositionUpdateEvent(state);
-            (_a = this._positionUpdateEvent) === null || _a === void 0 ? void 0 : _a.sendEvent(evt, targetClientId).catch((err) => {
+            this._positionUpdateEvent
+                ?.sendEvent(evt, targetClientId)
+                .catch((err) => {
                 this._logger.sendErrorEvent(TelemetryEvents.SessionCoordinator
                     .PositionUpdateEventError, err);
             });
@@ -487,7 +477,7 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter {
             // send a local only position update event that was not sent as a signal, and use to handle local
             // position update for clients that have canSendPositionUpdates==false, but are suspending
             const evt = this._groupState.createPositionUpdateEvent(state);
-            (_b = this._positionUpdateEvent) === null || _b === void 0 ? void 0 : _b.sendLocalEvent(evt).catch((err) => {
+            this._positionUpdateEvent?.sendLocalEvent(evt).catch((err) => {
                 this._logger.sendErrorEvent(TelemetryEvents.SessionCoordinator.PositionUpdateEventError, err);
             });
         }
@@ -496,49 +486,47 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter {
             this._groupState.syncLocalMediaSession();
         }
     }
-    createChildren(acceptTransportChangesFrom) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Create event scopes
-            const scope = new LiveEventScope(this._runtime, this._liveRuntime, acceptTransportChangesFrom);
-            const unrestrictedScope = new LiveEventScope(this._runtime, this._liveRuntime);
-            // Initialize internal coordinator state
-            this._groupState = new GroupCoordinatorState(this._runtime, this._liveRuntime, this._maxPlaybackDrift, this._positionUpdateInterval, this._getPlayerState);
-            this._groupState.on(GroupCoordinatorStateEvents.triggeraction, (evt) => this.emit(evt.name, evt));
-            this._groupState.on(GroupCoordinatorStateEvents.triggeractionignored, (evt) => this.emit(evt.name, evt));
-            // Listen for track changes
-            this._setTrackEvent = new LiveEventTarget(scope, "setTrack", (event, local) => this._groupState.handleSetTrack(event, local));
-            this._setTrackDataEvent = new LiveEventTarget(scope, "setTrackData", (event, local) => this._groupState.handleSetTrackData(event, local));
-            // Listen for transport commands
-            this._playEvent = new LiveEventTarget(scope, "play", (event, local) => this._groupState.handleTransportCommand(event, local));
-            this._pauseEvent = new LiveEventTarget(scope, "pause", (event, local) => this._groupState.handleTransportCommand(event, local));
-            this._seekToEvent = new LiveEventTarget(scope, "seekTo", (event, local) => this._groupState.handleTransportCommand(event, local));
-            this._rateChangeEvent = new LiveEventTarget(scope, "rateChange", (event, local) => {
-                this._groupState.handleRateChangeCommand(event, local);
+    async createChildren(acceptTransportChangesFrom) {
+        // Create event scopes
+        const scope = new LiveEventScope(this._runtime, this._liveRuntime, acceptTransportChangesFrom);
+        const unrestrictedScope = new LiveEventScope(this._runtime, this._liveRuntime);
+        // Initialize internal coordinator state
+        this._groupState = new GroupCoordinatorState(this._runtime, this._liveRuntime, this._maxPlaybackDrift, this._positionUpdateInterval, this._getPlayerState);
+        this._groupState.on(GroupCoordinatorStateEvents.triggeraction, (evt) => this.emit(evt.name, evt));
+        this._groupState.on(GroupCoordinatorStateEvents.triggeractionignored, (evt) => this.emit(evt.name, evt));
+        // Listen for track changes
+        this._setTrackEvent = new LiveEventTarget(scope, "setTrack", (event, local) => this._groupState.handleSetTrack(event, local));
+        this._setTrackDataEvent = new LiveEventTarget(scope, "setTrackData", (event, local) => this._groupState.handleSetTrackData(event, local));
+        // Listen for transport commands
+        this._playEvent = new LiveEventTarget(scope, "play", (event, local) => this._groupState.handleTransportCommand(event, local));
+        this._pauseEvent = new LiveEventTarget(scope, "pause", (event, local) => this._groupState.handleTransportCommand(event, local));
+        this._seekToEvent = new LiveEventTarget(scope, "seekTo", (event, local) => this._groupState.handleTransportCommand(event, local));
+        this._rateChangeEvent = new LiveEventTarget(scope, "rateChange", (event, local) => {
+            this._groupState.handleRateChangeCommand(event, local);
+        });
+        // Listen for position updates
+        this._positionUpdateEvent = new LiveEventTarget(unrestrictedScope, "positionUpdate", (event, local) => this._groupState.handlePositionUpdate(event, local));
+        this._synchronizer = new LiveObjectSynchronizer(this._id, this._runtime, this._liveRuntime);
+        this._synchronizer.onJoinedListener = (clientId, timestamp) => {
+            this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.RemoteConnectReceived, null, {
+                correlationId: LiveTelemetryLogger.formatCorrelationId(clientId, timestamp),
             });
-            // Listen for position updates
-            this._positionUpdateEvent = new LiveEventTarget(unrestrictedScope, "positionUpdate", (event, local) => this._groupState.handlePositionUpdate(event, local));
-            this._synchronizer = new LiveObjectSynchronizer(this._id, this._runtime, this._liveRuntime);
-            this._synchronizer.onJoinedListener = (clientId, timestamp) => {
-                this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.RemoteConnectReceived, null, {
-                    correlationId: LiveTelemetryLogger.formatCorrelationId(clientId, timestamp),
-                });
-                // Immediately send a position update
-                try {
-                    const state = this._getPlayerState();
-                    // Send only to the user that joined the session using the targetClientId prop.
-                    // This ensures that only the user that connected receives this one-time position update, minimizing costs.
-                    this.sendPositionUpdate(state, clientId);
-                }
-                catch (err) {
-                    // if player is not setup yet, local client might have also just joined and can't send its position.
-                    const playerNotSetup = isErrorLike(err) &&
-                        err.message.includes("LiveMediaSession:getCurrentPlayerState");
-                    if (!playerNotSetup) {
-                        throw err;
-                    }
+            // Immediately send a position update
+            try {
+                const state = this._getPlayerState();
+                // Send only to the user that joined the session using the targetClientId prop.
+                // This ensures that only the user that connected receives this one-time position update, minimizing costs.
+                this.sendPositionUpdate(state, clientId);
+            }
+            catch (err) {
+                // if player is not setup yet, local client might have also just joined and can't send its position.
+                const playerNotSetup = isErrorLike(err) &&
+                    err.message.includes("LiveMediaSession:getCurrentPlayerState");
+                if (!playerNotSetup) {
+                    throw err;
                 }
-            };
-        });
+            }
+        };
     }
     getPlayerPosition() {
         const { positionState, playbackState } = this._getPlayerState();