@dxos/plugin-thread 0.8.1-staging.9eaf14f → 0.8.2-main.10c050d

package/src/calls/call-swarm-synchronizer.ts

@@ -0,0 +1,350 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import md5Hex from 'md5-hex';
+
+import { DeferredTask, Event, scheduleTaskInterval, synchronized } from '@dxos/async';
+import { type Identity } from '@dxos/client/halo';
+import { Context, Resource } from '@dxos/context';
+import { generateName } from '@dxos/display-name';
+import { invariant } from '@dxos/invariant';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { buf } from '@dxos/protocols/buf';
+import { ActivitySchema } from '@dxos/protocols/buf/dxos/edge/calls_pb';
+import { type Device, type NetworkService } from '@dxos/protocols/proto/dxos/client/services';
+import { ConnectionState, type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
+import { isNonNullable } from '@dxos/util';
+
+import { codec, type ActivityState, type UserState } from './types';
+
+export type CallState = {
+  /**
+   * Room id.
+   */
+  roomId?: string;
+
+  /**
+   * All users states in the swarm.
+   */
+  users?: UserState[];
+
+  /**
+   * Self state inside swarm.
+   */
+  self?: UserState;
+
+  /**
+   * Swarm synchronized CRDT transcription. Last write wins.
+   */
+  activities?: Record<string, ActivityState>;
+
+  raisedHand?: boolean;
+  speaking?: boolean;
+  joined?: boolean;
+
+  /**
+   * Tracks pushed by self to calls service.
+   */
+  tracks?: UserState['tracks'];
+};
+
+export type CallSwarmSynchronizerParams = { networkService: NetworkService };
+
+/**
+ * Period for peer to reconnect to the call swarm gracefully if connection was lost abruptly.
+ */
+const DISCONNECTED_ABRUPT_TIMEOUT = 10_000; // [ms]
+
+/**
+ * Sends and receives state to/from Swarm network.
+ */
+export class CallSwarmSynchronizer extends Resource {
+  public readonly stateUpdated = new Event<CallState>();
+
+  private readonly _state: CallState = { activities: {} };
+  private readonly _networkService: NetworkService;
+  private _lastSwarmEvent?: SwarmResponse = undefined;
+  private _reconcileSwarmStateTask?: DeferredTask = undefined;
+
+  private _identityKey?: string = undefined;
+  private _deviceKey?: string = undefined;
+  private _displayName?: string = undefined;
+
+  private _swarmCtx?: Context = undefined;
+
+  private _sendStateTask?: DeferredTask = undefined;
+
+  constructor({ networkService }: CallSwarmSynchronizerParams) {
+    super();
+    this._networkService = networkService;
+  }
+
+  /**
+   * @internal
+   */
+  _getState(): CallState {
+    return this._state;
+  }
+
+  setRaisedHand(raisedHand: boolean): void {
+    if (this._state.raisedHand === raisedHand) {
+      return;
+    }
+
+    this._state.raisedHand = raisedHand;
+    this._notifyAndSchedule();
+  }
+
+  setSpeaking(speaking: boolean): void {
+    if (this._state.speaking === speaking) {
+      return;
+    }
+
+    this._state.speaking = speaking;
+    this._notifyAndSchedule();
+  }
+
+  setJoined(joined: boolean): void {
+    if (this._state.joined === joined) {
+      return;
+    }
+
+    this._state.joined = joined;
+    this._notifyAndSchedule();
+  }
+
+  setTracks(tracks: UserState['tracks']): void {
+    this._state.tracks = { ...this._state.tracks, ...tracks };
+    this._notifyAndSchedule();
+  }
+
+  setActivity(key: string, payload: ActivityState['payload']): void {
+    const lamportTimestamp = LamportTimestampCrdt.increment(
+      this._state.activities?.[key]?.lamportTimestamp ?? { id: this._deviceKey },
+    );
+    this._state.activities![key] = { lamportTimestamp, payload };
+
+    this._notifyAndSchedule();
+  }
+
+  /**
+   * @internal
+   */
+  _setIdentity(identity: Identity): void {
+    this._identityKey = identity.identityKey.toHex();
+    this._displayName = identity.profile?.displayName ?? generateName(identity.identityKey.toHex());
+  }
+
+  /**
+   * @internal
+   */
+  _setDevice(device: Device): void {
+    this._deviceKey = device.deviceKey.toHex();
+  }
+
+  /**
+   * @internal
+   */
+  _setRoomId(roomId?: string): void {
+    if (this._swarmCtx) {
+      log.verbose('joined to a different room', { roomId });
+      return;
+    }
+
+    this._state.roomId = roomId;
+  }
+
+  protected override async _open(): Promise<void> {
+    this._sendStateTask = new DeferredTask(this._ctx, async () => {
+      await this._sendState();
+    });
+
+    this._reconcileSwarmStateTask = new DeferredTask(this._ctx, async () => {
+      await this._reconcileSwarmState();
+    });
+  }
+
+  protected override async _close(): Promise<void> {
+    this._sendStateTask = undefined;
+    this._reconcileSwarmStateTask = undefined;
+  }
+
+  @synchronized
+  async join(): Promise<void> {
+    invariant(this._state.roomId);
+    invariant(!this._swarmCtx, 'Already joined');
+
+    this._swarmCtx = new Context();
+    const topic = getTopic(this._state.roomId);
+    log('joining swarm', { topic, peer: { identityKey: this._identityKey, peerKey: this._deviceKey } });
+    const stream = this._networkService.subscribeSwarmState({ topic });
+    stream.subscribe((event) => this._processSwarmEvent(event));
+
+    const cleanup = () => {
+      void stream.close();
+      if (topic && this._identityKey && this._deviceKey) {
+        log('leaving swarm', { topic, peer: { identityKey: this._identityKey, peerKey: this._deviceKey } });
+        void this._networkService
+          .leaveSwarm({
+            topic,
+            peer: { identityKey: this._identityKey, peerKey: this._deviceKey },
+          })
+          .catch((err) => log.catch(err));
+      }
+      window.removeEventListener('beforeunload', cleanup);
+    };
+    window.addEventListener('beforeunload', cleanup);
+    this._swarmCtx.onDispose(cleanup);
+
+    this._notifyAndSchedule();
+  }
+
+  @synchronized
+  async leave(): Promise<void> {
+    if (!this._swarmCtx) {
+      return;
+    }
+
+    await this._swarmCtx.dispose();
+    this._swarmCtx = undefined;
+
+    this._state.users = undefined;
+    this._state.self = undefined;
+  }
+
+  async querySwarm(roomId: string) {
+    const topic = getTopic(roomId);
+    const swarm = await this._networkService.querySwarm({ topic });
+    return swarm.peers ?? [];
+  }
+
+  /**
+   * Notify and schedule send state task.
+   */
+  private _notifyAndSchedule(): void {
+    this.stateUpdated.emit(this._state);
+    if (this._state.joined) {
+      this._sendStateTask?.schedule();
+    }
+  }
+
+  private async _sendState(): Promise<void> {
+    if (!this._state.roomId || !this._identityKey || !this._deviceKey || !this._state.joined) {
+      return;
+    }
+
+    const state: UserState = {
+      ...this._state,
+      id: this._deviceKey,
+      name: this._displayName,
+      activities: this._state.activities
+        ? Object.fromEntries(
+            Object.entries(this._state.activities).map(([key, activity]) => [
+              key,
+              buf.create(ActivitySchema, activity),
+            ]),
+          )
+        : {},
+    };
+
+    await this._networkService.joinSwarm({
+      topic: getTopic(this._state.roomId),
+      peer: {
+        identityKey: this._identityKey,
+        peerKey: this._deviceKey,
+        state: codec.encode(state),
+      },
+    });
+  }
+
+  private _processSwarmEvent(swarmEvent: SwarmResponse): void {
+    if (!this._state.joined) {
+      return;
+    }
+
+    this._lastSwarmEvent = swarmEvent;
+    this._reconcileSwarmStateTask!.schedule();
+  }
+
+  private async _reconcileSwarmState(): Promise<void> {
+    const swarmEvent = this._lastSwarmEvent;
+    invariant(swarmEvent);
+    // We include inactive peers that were disconnected abruptly and have not yet reconnected to not drop them from call.
+    // Websocket connection could be unstable and we include graceful period for peers to reconnect.
+    const peers = [
+      ...(swarmEvent.peers ?? []),
+      ...(swarmEvent.inactivePeers ?? []).filter(
+        ({ disconnected, connectionState }) =>
+          connectionState === ConnectionState.DISCONNECTED_ABRUPT &&
+          disconnected &&
+          disconnected > Date.now() - DISCONNECTED_ABRUPT_TIMEOUT,
+      ),
+    ].sort((peer1, peer2) => peer1.peerKey.localeCompare(peer2.peerKey));
+    const users = peers
+      .map((peer) => {
+        try {
+          return codec.decode(peer.state!);
+        } catch (error) {
+          log.error('error decoding peer state', { error, peer });
+          return undefined;
+        }
+      })
+      .filter(isNonNullable);
+    this._state.users = users;
+    this._state.self = users.find((user) => user.id === this._deviceKey);
+    log('reconciling swarm state', { users });
+    if (users.length === 0) {
+      return;
+    }
+
+    const activityKeys = new Set<string>(users.flatMap((user) => Object.keys(user.activities)));
+    [...activityKeys].forEach((key) => {
+      const activities = users.map((user) => user.activities?.[key]).filter(isNonNullable);
+      const lastActivity = LamportTimestampCrdt.getLastState(activities);
+      if (
+        lastActivity &&
+        lastActivity.lamportTimestamp!.version! > (this._state.activities![key]?.lamportTimestamp?.version ?? 0)
+      ) {
+        this._state.activities![key] = lastActivity;
+      }
+    });
+    this.stateUpdated.emit(this._state);
+
+    // Schedule next reconcile if there are inactive peer to drop them after timeout.
+    if (peers.some((peer) => peer.connectionState !== ConnectionState.CONNECTED)) {
+      scheduleTaskInterval(
+        this._ctx,
+        async () => this._reconcileSwarmStateTask!.schedule(),
+        Math.min(DISCONNECTED_ABRUPT_TIMEOUT / 2, 1000),
+      );
+    }
+  }
+}
+
+type LamportTimestamp = ActivityState['lamportTimestamp'];
+
+// TODO(mykola): Factor out.
+class LamportTimestampCrdt {
+  static getLastState<T extends { lamportTimestamp?: LamportTimestamp }>(states: T[]): T | undefined {
+    const maxTimestamp = Math.max(...states.map((state) => state.lamportTimestamp?.version ?? 0));
+    const sortedStates = states
+      .filter(
+        (state) =>
+          state.lamportTimestamp && state.lamportTimestamp.version === maxTimestamp && state.lamportTimestamp.id,
+      )
+      .sort((a, b) => a.lamportTimestamp!.id!.localeCompare(b.lamportTimestamp!.id!));
+    return sortedStates[0];
+  }
+
+  static increment(timestamp: LamportTimestamp): LamportTimestamp {
+    return {
+      ...(timestamp ?? {}),
+      version: (timestamp?.version ?? 0) + 1,
+    };
+  }
+}
+
+// TODO(mykola): Delete once we refactor swarm to accept string as topic.
+const getTopic = (roomId: string): PublicKey => PublicKey.fromHex(md5Hex(roomId));

package/src/calls/index.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './call-manager';
+export * from './call-swarm-synchronizer';
+export * from './media-manager';
+export * from './speaking-monitor';
+export * from './types';
+export * from './util';

package/src/calls/media-manager.ts

@@ -0,0 +1,342 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { DeferredTask, Event, sleep, synchronized } from '@dxos/async';
+import { cancelWithContext, type Context, Resource } from '@dxos/context';
+import { log } from '@dxos/log';
+
+import { SpeakingMonitor } from './speaking-monitor';
+import { TrackNameCodec, type EncodedTrackName, type TrackObject } from './types';
+import {
+  type CallsServiceConfig,
+  CallsServicePeer,
+  createBlackCanvasStreamTrack,
+  createInaudibleAudioStreamTrack,
+  getScreenshare,
+  getUserMediaTrack,
+} from './util';
+
+export type MediaState = {
+  audioDeviceId?: string;
+  audioEnabled?: boolean;
+  audioTrack?: MediaStreamTrack;
+
+  videoDeviceId?: string;
+  videoEnabled?: boolean;
+  videoTrack?: MediaStreamTrack;
+  videoStream?: MediaStream;
+
+  screenshareEnabled?: boolean;
+  screenshareTrack?: MediaStreamTrack;
+  screenshareVideoStream?: MediaStream;
+
+  pushedVideoTrack?: TrackObject;
+  pushedAudioTrack?: TrackObject;
+  pushedScreenshareTrack?: TrackObject;
+  peer?: CallsServicePeer;
+
+  pulledAudioTracks: Record<EncodedTrackName, { track: MediaStreamTrack; ctx: Context }>;
+  /**
+   * Includes video feeds and screenshare feeds of other participants.
+   */
+  pulledVideoStreams: Record<EncodedTrackName, { stream: MediaStream; ctx: Context }>;
+};
+
+// TOOD(burdon): Hard coded.
+const VIDEO_WIDTH = 1280;
+const VIDEO_HEIGHT = 720;
+const MAX_WEB_CAM_FRAMERATE = 24;
+const MAX_WEB_CAM_BITRATE = 120_0000;
+const RETRY_INTERVAL = 500;
+
+export type MediaManagerParams = {
+  serviceConfig: CallsServiceConfig;
+};
+
+export class MediaManager extends Resource {
+  public readonly stateUpdated = new Event<MediaState>();
+  private readonly _state: MediaState = { pulledVideoStreams: {}, pulledAudioTracks: {} };
+  private _speakingMonitor?: SpeakingMonitor = undefined;
+
+  private _trackToReconcile: EncodedTrackName[] = [];
+  private _blackCanvasStreamTrack?: MediaStreamTrack = undefined;
+  private _inaudibleAudioStreamTrack?: MediaStreamTrack = undefined;
+  private _pushTracksTask?: DeferredTask = undefined;
+  private _pullTracksTask?: DeferredTask = undefined;
+
+  get isSpeaking() {
+    return this._speakingMonitor?.isSpeaking;
+  }
+
+  /**
+   * @internal
+   */
+  _getState(): MediaState {
+    return this._state;
+  }
+
+  protected override async _open(): Promise<void> {
+    this._blackCanvasStreamTrack = await createBlackCanvasStreamTrack({
+      ctx: this._ctx,
+      width: VIDEO_WIDTH,
+      height: VIDEO_HEIGHT,
+    });
+    this._state.videoTrack = this._blackCanvasStreamTrack;
+    this._state.videoStream = new MediaStream();
+    this._state.videoStream.addTrack(this._state.videoTrack);
+
+    this._inaudibleAudioStreamTrack = await createInaudibleAudioStreamTrack({ ctx: this._ctx });
+    this._state.audioTrack = this._inaudibleAudioStreamTrack;
+
+    this._pushTracksTask = new DeferredTask(this._ctx, async () => {
+      await this._pushTracks();
+    });
+    this._pullTracksTask = new DeferredTask(this._ctx, async () => {
+      await this._reconcilePulledMedia();
+    });
+  }
+
+  protected override async _close(): Promise<void> {
+    void this._speakingMonitor?.close();
+    this._state.videoTrack && this._state.videoStream?.removeTrack(this._state.videoTrack);
+    this._state.audioTrack?.stop();
+    this._state.videoTrack?.stop();
+    this._state.screenshareTrack?.stop();
+    this._pushTracksTask = undefined;
+    this._pullTracksTask = undefined;
+  }
+
+  @synchronized
+  async join(serviceConfig: CallsServiceConfig): Promise<void> {
+    this._state.peer = new CallsServicePeer(serviceConfig);
+    await this._state.peer!.open();
+    this._pushTracksTask!.schedule();
+  }
+
+  @synchronized
+  async leave(): Promise<void> {
+    await Promise.all(Object.values(this._state.pulledAudioTracks).map(({ ctx }) => ctx.dispose()));
+    await Promise.all(Object.values(this._state.pulledVideoStreams).map(({ ctx }) => ctx.dispose()));
+    this._trackToReconcile = [];
+    await this._state.peer?.close();
+    this._state.peer = undefined;
+    this._state.pushedVideoTrack = undefined;
+    this._state.pushedAudioTrack = undefined;
+    this._state.pushedScreenshareTrack = undefined;
+    this._state.pulledAudioTracks = {};
+    this._state.pulledVideoStreams = {};
+  }
+
+  async turnVideoOn(): Promise<void> {
+    this._state.videoStream!.removeTrack(this._state.videoTrack!);
+    this._state.videoTrack = await getUserMediaTrack('videoinput', { width: VIDEO_WIDTH, height: VIDEO_HEIGHT });
+    this._state.videoStream!.addTrack(this._state.videoTrack);
+    this._state.videoEnabled = true;
+    this.stateUpdated.emit(this._state);
+    this._pushTracksTask!.schedule();
+  }
+
+  async turnVideoOff(): Promise<void> {
+    if (this._state.videoTrack !== this._blackCanvasStreamTrack) {
+      this._state.videoStream!.removeTrack(this._state.videoTrack!);
+      this._state.videoTrack?.stop();
+      this._state.videoTrack = this._blackCanvasStreamTrack;
+      this._state.videoStream!.addTrack(this._state.videoTrack!);
+    }
+
+    this._state.videoEnabled = false;
+    this.stateUpdated.emit(this._state);
+    this._pushTracksTask!.schedule();
+  }
+
+  // TODO(mykola): Change to `setAudioEnabled(enabled: boolean)`.
+  async turnAudioOn(): Promise<void> {
+    void this._speakingMonitor?.close();
+    this._state.audioEnabled = true;
+    this._state.audioTrack = await getUserMediaTrack('audioinput', {
+      echoCancellation: true,
+      noiseSuppression: true,
+      autoGainControl: true,
+      sampleRate: 16_000,
+    });
+    this.stateUpdated.emit(this._state);
+    this._pushTracksTask!.schedule();
+    this._speakingMonitor = new SpeakingMonitor(this._state.audioTrack!);
+    this._speakingMonitor.speakingChanged.on(this._ctx, () => this.stateUpdated.emit(this._state));
+    void this._speakingMonitor.open();
+  }
+
+  async turnAudioOff(): Promise<void> {
+    void this._speakingMonitor?.close();
+    this._speakingMonitor = undefined;
+    if (this._state.audioTrack !== this._inaudibleAudioStreamTrack) {
+      this._state.audioTrack?.stop();
+      this._state.audioTrack = this._inaudibleAudioStreamTrack;
+    }
+    this._state.audioEnabled = false;
+    this.stateUpdated.emit(this._state);
+    this._pushTracksTask!.schedule();
+  }
+
+  async turnScreenshareOn(): Promise<void> {
+    const ms = await getScreenshare({ contentHint: 'text' });
+    this._state.screenshareVideoStream = ms;
+    this._state.screenshareTrack = ms.getVideoTracks()[0];
+    this._state.screenshareEnabled = true;
+    this.stateUpdated.emit(this._state);
+    this._pushTracksTask!.schedule();
+  }
+
+  async turnScreenshareOff(): Promise<void> {
+    this._state.screenshareEnabled = false;
+    this._state.screenshareTrack?.stop();
+    this._state.screenshareTrack = undefined;
+    this.stateUpdated.emit(this._state);
+    this._pushTracksTask!.schedule();
+  }
+
+  /**
+   * @internal
+   */
+  _schedulePullTracks(tracks?: EncodedTrackName[]): void {
+    if (
+      !tracks ||
+      (this._trackToReconcile.every((name) => tracks.includes(name)) && this._trackToReconcile.length === tracks.length)
+    ) {
+      return;
+    }
+
+    this._trackToReconcile = tracks;
+    this._pullTracksTask!.schedule();
+  }
+
+  private async _reconcilePulledMedia(): Promise<void> {
+    log('reconciling tracks');
+    // TODO(mykola): Currently cloudflare fails if you try to pull track immediately after pushing it.
+    // Add retry logic, remove sleep.
+    // Wait for cloudflare to process the track.
+    await cancelWithContext(this._ctx, sleep(800));
+    const trackNames = this._trackToReconcile;
+
+    const tracksToPull = trackNames.filter(
+      (name) => !this._state.pulledAudioTracks[name] && !this._state.pulledVideoStreams[name],
+    );
+
+    const audioTracksToClose = Object.entries(this._state.pulledAudioTracks).filter(
+      ([key]) => !trackNames.some((name) => name === key),
+    );
+
+    const videoStreamsToClose = Object.entries(this._state.pulledVideoStreams).filter(
+      ([key]) => !trackNames.some((name) => name === key),
+    );
+
+    log('reconciling tracks', {
+      trackNames,
+      tracksToPull,
+      videoStreamsToClose,
+      audioTracksToClose,
+      currentAudioTracks: Object.keys(this._state.pulledAudioTracks),
+      currentVideoStreams: Object.keys(this._state.pulledVideoStreams),
+    });
+
+    // Pull new tracks.
+    await Promise.all(tracksToPull.map((name) => this._pullTrack(name)));
+
+    // Close old tracks.
+    await Promise.all([...audioTracksToClose, ...videoStreamsToClose].map(([_, { ctx }]) => ctx.dispose()));
+
+    log('reconciled tracks', {
+      currentAudioTracks: Object.keys(this._state.pulledAudioTracks),
+      currentVideoStreams: Object.keys(this._state.pulledVideoStreams),
+    });
+    this.stateUpdated.emit(this._state);
+  }
+
+  private async _pushTracks(): Promise<void> {
+    if (!this._state.peer?.isOpen) {
+      return;
+    }
+
+    let updated = false;
+    const [pushedVideoTrack, pushedAudioTrack, pushedScreenshareTrack] = await Promise.all([
+      this._pushTrack(this._state.videoTrack, this._state.pushedVideoTrack, [
+        { maxFramerate: MAX_WEB_CAM_FRAMERATE, maxBitrate: MAX_WEB_CAM_BITRATE },
+      ]),
+      this._pushTrack(this._state.audioTrack, this._state.pushedAudioTrack, [{ networkPriority: 'high' }]),
+      this._pushTrack(this._state.screenshareTrack, this._state.pushedScreenshareTrack),
+    ]);
+
+    if (pushedVideoTrack !== this._state.pushedVideoTrack) {
+      this._state.pushedVideoTrack = pushedVideoTrack;
+      updated = true;
+    }
+    if (pushedAudioTrack !== this._state.pushedAudioTrack) {
+      this._state.pushedAudioTrack = pushedAudioTrack;
+      updated = true;
+    }
+    if (pushedScreenshareTrack !== this._state.pushedScreenshareTrack) {
+      this._state.pushedScreenshareTrack = pushedScreenshareTrack;
+      updated = true;
+    }
+    if (!updated) {
+      return;
+    }
+
+    this.stateUpdated.emit(this._state);
+  }
+
+  private async _pullTrack(name: EncodedTrackName): Promise<void> {
+    const ctx = this._ctx.derive();
+    try {
+      const trackData = TrackNameCodec.decode(name);
+      const track = await this._state.peer!.pullTrack({ trackData, ctx });
+      if (track?.readyState === 'ended') {
+        throw new Error('Pulled track ended immediately');
+      }
+
+      switch (track?.kind) {
+        case 'audio': {
+          this._state.pulledAudioTracks[name] = { track, ctx };
+          ctx.onDispose(() => delete this._state.pulledAudioTracks[name]);
+          break;
+        }
+        case 'video': {
+          const mediaStream = new MediaStream();
+          mediaStream.addTrack(track);
+          this._state.pulledVideoStreams[name] = { stream: mediaStream, ctx };
+          ctx.onDispose(() => {
+            mediaStream.removeTrack(track);
+            track.stop();
+            delete this._state.pulledVideoStreams[name];
+          });
+          break;
+        }
+        default:
+          throw new Error(`Invalid track kind: ${track?.kind}`);
+      }
+    } catch (err) {
+      log.warn('failed to pull track', { err, name });
+      void ctx.dispose();
+      await cancelWithContext(this._ctx, sleep(RETRY_INTERVAL));
+      log.warn('retrying pull track', { name });
+      this._pullTracksTask!.schedule();
+    }
+  }
+
+  private async _pushTrack(
+    track?: MediaStreamTrack,
+    previousTrack?: TrackObject,
+    encodings?: RTCRtpEncodingParameters[],
+  ): Promise<TrackObject | undefined> {
+    if (!track && !previousTrack) {
+      return;
+    }
+
+    return this._state.peer!.pushTrack({
+      track: track ?? null,
+      previousTrack,
+      encodings,
+    });
+  }
+}