@dxos/plugin-thread 0.8.3-staging.0fa589b → 0.8.4-main.03d5cd7b56

package/src/calls/call-manager.ts

@@ -2,17 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-import { computed } from '@preact/signals-core';
+import { Atom, type Registry } from '@effect-atom/atom-react';
 
 import { Event, synchronized } from '@dxos/async';
 import { type Client } from '@dxos/client';
 import { Resource } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
-import { live } from '@dxos/live-object';
 import { type Tracks } from '@dxos/protocols/proto/dxos/edge/calls';
 import { isNonNullable } from '@dxos/util';
 
-import { CallSwarmSynchronizer, type CallState } from './call-swarm-synchronizer';
+import { type CallState, CallSwarmSynchronizer } from './call-swarm-synchronizer';
 import { MediaManager, type MediaState } from './media-manager';
 import { type ActivityState, CALLS_URL, type EncodedTrackName, TrackNameCodec, type UserState } from './types';
 
@@ -31,80 +30,103 @@ export class CallManager extends Resource {
   public readonly left = new Event<string>();
 
   /**
-   * Live object state. Is changed on internal events.
+   * Atom-based state. Updated via `_updateState()`.
    * CAUTION: Do not change directly.
    */
-  private readonly _state = live<GlobalState>({
+  private readonly _stateAtom = Atom.make<GlobalState>({
     call: {},
     media: { pulledAudioTracks: {}, pulledVideoStreams: {} },
   });
 
-  // TODO(wittjosiah): This shouldn't be necessary, live-object's signals should be granular.
-  private readonly _raisedHandSignal = computed(() => this._state.call.raisedHand ?? false);
-  private readonly _speakingSignal = computed(() => this._state.call.speaking ?? false);
-  private readonly _joinedSignal = computed(() => this._state.call.joined ?? false);
+  // Derived atoms for reactive subscriptions.
+  private readonly _roomIdAtom = Atom.make((get) => get(this._stateAtom).call.roomId);
+  private readonly _raisedHandAtom = Atom.make((get) => get(this._stateAtom).call.raisedHand ?? false);
+  private readonly _speakingAtom = Atom.make((get) => get(this._stateAtom).call.speaking ?? false);
+  private readonly _joinedAtom = Atom.make((get) => get(this._stateAtom).call.joined ?? false);
+  private readonly _selfAtom = Atom.make((get) => get(this._stateAtom).call.self ?? {});
+  private readonly _tracksAtom = Atom.make((get) => get(this._stateAtom).call.tracks ?? {});
+  private readonly _usersAtom = Atom.make((get) => get(this._stateAtom).call.users ?? []);
+  private readonly _mediaAtom = Atom.make((get) => get(this._stateAtom).media);
+  private readonly _audioTracksToPlayAtom = Atom.make((get) => {
+    const state = get(this._stateAtom);
+    return (state.call.users ?? [])
+      .map((user: UserState) => (user.tracks?.audioEnabled ? user.tracks?.audio : undefined))
+      .filter(isNonNullable)
+      .map((track: string) => state.media.pulledAudioTracks[track as EncodedTrackName]?.track)
+      .filter(isNonNullable);
+  });
+  private readonly _videoStreamAtomFamily = Atom.family<EncodedTrackName, Atom.Atom<MediaStream | undefined>>((name) =>
+    Atom.make((get) => get(this._stateAtom).media.pulledVideoStreams[name]?.stream),
+  );
+  private readonly _activityAtomFamily = Atom.family<string, Atom.Atom<ActivityState | undefined>>((key) =>
+    Atom.make((get) => get(this._stateAtom).call.activities?.[key]),
+  );
 
   private readonly _swarmSynchronizer: CallSwarmSynchronizer;
   private readonly _mediaManager: MediaManager;
 
-  /** @reactive */
-  get roomId(): string | undefined {
-    return this._state.call.roomId;
+  //
+  // Derived atoms for reactive UI subscriptions.
+  //
+
+  /** Derived atom for roomId. */
+  get roomIdAtom(): Atom.Atom<string | undefined> {
+    return this._roomIdAtom;
   }
 
-  /** @reactive */
-  get raisedHand(): boolean {
-    return this._raisedHandSignal.value;
+  /** Derived atom for raisedHand. */
+  get raisedHandAtom(): Atom.Atom<boolean> {
+    return this._raisedHandAtom;
   }
 
-  /** @reactive */
-  get speaking(): boolean {
-    return this._speakingSignal.value;
+  /** Derived atom for speaking. */
+  get speakingAtom(): Atom.Atom<boolean> {
+    return this._speakingAtom;
   }
 
-  /** @reactive */
-  get joined(): boolean {
-    return this._joinedSignal.value;
+  /** Derived atom for joined. */
+  get joinedAtom(): Atom.Atom<boolean> {
+    return this._joinedAtom;
   }
 
-  /** @reactive */
-  get self(): UserState {
-    return this._state.call.self ?? {};
+  /** Derived atom for self. */
+  get selfAtom(): Atom.Atom<UserState> {
+    return this._selfAtom;
   }
 
-  /** @reactive */
-  get tracks(): Tracks {
-    return this._state.call.tracks ?? {};
+  /** Derived atom for tracks. */
+  get tracksAtom(): Atom.Atom<Tracks> {
+    return this._tracksAtom;
   }
 
-  /** @reactive */
-  get users(): UserState[] {
-    return this._state.call.users ?? [];
+  /** Derived atom for users. */
+  get usersAtom(): Atom.Atom<UserState[]> {
+    return this._usersAtom;
   }
 
-  /** @reactive */
-  get media() {
-    return this._state.media;
+  /** Derived atom for media. */
+  get mediaAtom(): Atom.Atom<MediaState> {
+    return this._mediaAtom;
   }
 
-  /** @reactive */
-  get pulledAudioTracks() {
-    return Object.values(this._state.media.pulledAudioTracks).map((track) => track.track);
+  /** Derived atom for audioTracksToPlay. */
+  get audioTracksToPlayAtom(): Atom.Atom<MediaStreamTrack[]> {
+    return this._audioTracksToPlayAtom;
   }
 
-  /** @reactive */
-  get state() {
-    return this._state;
+  /** Returns the full state atom for reactive subscriptions. */
+  get stateAtom(): Atom.Atom<GlobalState> {
+    return this._stateAtom;
   }
 
-  /** @reactive */
-  getVideoStream(name?: EncodedTrackName): MediaStream | undefined {
-    return name ? this._state.media.pulledVideoStreams[name]?.stream : undefined;
+  /** Returns a derived atom for a video stream by name. */
+  videoStreamAtom(name: EncodedTrackName): Atom.Atom<MediaStream | undefined> {
+    return this._videoStreamAtomFamily(name);
   }
 
-  /** @reactive */
-  getActivity(key: string): ActivityState | undefined {
-    return this._state.call.activities?.[key];
+  /** Returns a derived atom for an activity by key. */
+  activityAtom(key: string): Atom.Atom<ActivityState | undefined> {
+    return this._activityAtomFamily(key);
   }
 
   setRoomId(roomId: string): void {
@@ -148,7 +170,10 @@ export class CallManager extends Resource {
   }
 
   // TODO(burdon): Can this be mocked?
-  constructor(private readonly _client: Client) {
+  constructor(
+    private readonly _client: Client,
+    private readonly _registry: Registry.Registry,
+  ) {
     super();
     this._client.config.getOrThrow('runtime.services.edge.url');
     const networkService = this._client.services.services.NetworkService;
@@ -201,12 +226,13 @@ export class CallManager extends Resource {
     this._swarmSynchronizer.setJoined(false);
     await this._swarmSynchronizer.leave();
     await this._mediaManager.leave();
-    this.roomId && this.left.emit(this.roomId);
+    const roomId = this._registry.get(this._roomIdAtom);
+    roomId && this.left.emit(roomId);
   }
 
   private _onCallStateUpdated(state: CallState): void {
     const tracksToPull = state.users
-      ?.filter((user) => user.joined && user.id !== state.self?.id)
+      ?.filter((user) => user.joined && user.id !== state.self!.id)
       ?.flatMap((user) => [user.tracks?.video, user.tracks?.audio, user.tracks?.screenshare])
       .filter(isNonNullable);
     this._mediaManager._schedulePullTracks(tracksToPull as EncodedTrackName[]);
@@ -236,7 +262,9 @@ export class CallManager extends Resource {
    * Only this method is allowed to change state.
    */
   private _updateState(): void {
-    this._state.call = this._swarmSynchronizer._getState();
-    this._state.media = this._mediaManager._getState();
+    this._registry.set(this._stateAtom, {
+      call: this._swarmSynchronizer._getState(),
+      media: this._mediaManager._getState(),
+    });
   }
 }

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

@@ -17,7 +17,7 @@ import { type Device, type NetworkService } from '@dxos/protocols/proto/dxos/cli
 import { ConnectionState, type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
 import { isNonNullable } from '@dxos/util';
 
-import { codec, type ActivityState, type UserState } from './types';
+import { type ActivityState, type UserState, codec } from './types';
 
 export type CallState = {
   /**
@@ -50,7 +50,7 @@ export type CallState = {
   tracks?: UserState['tracks'];
 };
 
-export type CallSwarmSynchronizerParams = { networkService: NetworkService };
+export type CallSwarmSynchronizerProps = { networkService: NetworkService };
 
 /**
  * Period for peer to reconnect to the call swarm gracefully if connection was lost abruptly.
@@ -76,7 +76,7 @@ export class CallSwarmSynchronizer extends Resource {
 
   private _sendStateTask?: DeferredTask = undefined;
 
-  constructor({ networkService }: CallSwarmSynchronizerParams) {
+  constructor({ networkService }: CallSwarmSynchronizerProps) {
     super();
     this._networkService = networkService;
   }

package/src/calls/media-manager.ts

@@ -3,11 +3,12 @@
 //
 
 import { DeferredTask, Event, sleep, synchronized } from '@dxos/async';
-import { cancelWithContext, type Context, Resource } from '@dxos/context';
+import { type Context, Resource, cancelWithContext } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
 import { SpeakingMonitor } from './speaking-monitor';
-import { TrackNameCodec, type EncodedTrackName, type TrackObject } from './types';
+import { type EncodedTrackName, TrackNameCodec, type TrackObject } from './types';
 import {
   type CallsServiceConfig,
   CallsServicePeer,
@@ -48,17 +49,23 @@ 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;
+const RETRY_INTERVAL = 100;
 
-export type MediaManagerParams = {
+export type MediaManagerProps = {
   serviceConfig: CallsServiceConfig;
 };
 
+const USE_INAUDIBLE_AUDIO = true;
+
 export class MediaManager extends Resource {
   public readonly stateUpdated = new Event<MediaState>();
-  private readonly _state: MediaState = { pulledVideoStreams: {}, pulledAudioTracks: {} };
-  private _speakingMonitor?: SpeakingMonitor = undefined;
 
+  private readonly _state: MediaState = {
+    pulledVideoStreams: {},
+    pulledAudioTracks: {},
+  };
+
+  private _speakingMonitor?: SpeakingMonitor = undefined;
   private _trackToReconcile: EncodedTrackName[] = [];
   private _blackCanvasStreamTrack?: MediaStreamTrack = undefined;
   private _inaudibleAudioStreamTrack?: MediaStreamTrack = undefined;
@@ -82,12 +89,15 @@ export class MediaManager extends Resource {
       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;
+    if (USE_INAUDIBLE_AUDIO) {
+      this._inaudibleAudioStreamTrack = await createInaudibleAudioStreamTrack({ ctx: this._ctx });
+      this._state.audioTrack = this._inaudibleAudioStreamTrack;
+    }
 
     this._pushTracksTask = new DeferredTask(this._ctx, async () => {
       await this._pushTracks();
@@ -132,6 +142,7 @@ export class MediaManager extends Resource {
     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();
@@ -170,11 +181,14 @@ export class MediaManager extends Resource {
   async turnAudioOff(): Promise<void> {
     void this._speakingMonitor?.close();
     this._speakingMonitor = undefined;
-    if (this._state.audioTrack !== this._inaudibleAudioStreamTrack) {
+    this._state.audioEnabled = false;
+    if (USE_INAUDIBLE_AUDIO && this._state.audioTrack !== this._inaudibleAudioStreamTrack) {
       this._state.audioTrack?.stop();
       this._state.audioTrack = this._inaudibleAudioStreamTrack;
+    } else {
+      this._state.audioTrack?.stop();
+      this._state.audioTrack = undefined;
     }
-    this._state.audioEnabled = false;
     this.stateUpdated.emit(this._state);
     this._pushTracksTask!.schedule();
   }
@@ -218,7 +232,6 @@ export class MediaManager extends Resource {
     // 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],
     );
@@ -241,7 +254,7 @@ export class MediaManager extends Resource {
     });
 
     // Pull new tracks.
-    await Promise.all(tracksToPull.map((name) => this._pullTrack(name)));
+    const pullResults = await Promise.all(tracksToPull.map((name) => this._pullTrack(name)));
 
     // Close old tracks.
     await Promise.all([...audioTracksToClose, ...videoStreamsToClose].map(([_, { ctx }]) => ctx.dispose()));
@@ -250,7 +263,14 @@ export class MediaManager extends Resource {
       currentAudioTracks: Object.keys(this._state.pulledAudioTracks),
       currentVideoStreams: Object.keys(this._state.pulledVideoStreams),
     });
+
     this.stateUpdated.emit(this._state);
+    if (pullResults.some(({ shouldRetry }) => shouldRetry)) {
+      await cancelWithContext(this._ctx, sleep(RETRY_INTERVAL));
+      log.info('retrying pull tracks', { tracksToPull });
+      invariant(this._pullTracksTask);
+      this._pullTracksTask.schedule();
+    }
   }
 
   private async _pushTracks(): Promise<void> {
@@ -259,38 +279,46 @@ export class MediaManager extends Resource {
     }
 
     let updated = false;
-    const [pushedVideoTrack, pushedAudioTrack, pushedScreenshareTrack] = await Promise.all([
-      this._pushTrack(this._state.videoTrack, this._state.pushedVideoTrack, [
+    const [pushVideoResult, pushAudioResult, pushScreenshareResult] = await Promise.all([
+      this._maybePushTrack(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),
+      this._maybePushTrack(this._state.audioTrack, this._state.pushedAudioTrack, [{ networkPriority: 'high' }]),
+      this._maybePushTrack(this._state.screenshareTrack, this._state.pushedScreenshareTrack),
     ]);
 
-    if (pushedVideoTrack !== this._state.pushedVideoTrack) {
-      this._state.pushedVideoTrack = pushedVideoTrack;
+    if (pushVideoResult.track !== this._state.pushedVideoTrack) {
+      this._state.pushedVideoTrack = pushVideoResult.track;
       updated = true;
     }
-    if (pushedAudioTrack !== this._state.pushedAudioTrack) {
-      this._state.pushedAudioTrack = pushedAudioTrack;
+    if (pushAudioResult.track !== this._state.pushedAudioTrack) {
+      this._state.pushedAudioTrack = pushAudioResult.track;
       updated = true;
     }
-    if (pushedScreenshareTrack !== this._state.pushedScreenshareTrack) {
-      this._state.pushedScreenshareTrack = pushedScreenshareTrack;
+    if (pushScreenshareResult.track !== this._state.pushedScreenshareTrack) {
+      this._state.pushedScreenshareTrack = pushScreenshareResult.track;
       updated = true;
     }
-    if (!updated) {
-      return;
+
+    const shouldRetry = pushVideoResult.shouldRetry || pushAudioResult.shouldRetry || pushScreenshareResult.shouldRetry;
+    if (updated) {
+      this.stateUpdated.emit(this._state);
     }
 
-    this.stateUpdated.emit(this._state);
+    if (shouldRetry) {
+      await cancelWithContext(this._ctx, sleep(RETRY_INTERVAL));
+      log.info('retrying push tracks', { pushVideoResult, pushAudioResult, pushScreenshareResult });
+      invariant(this._pushTracksTask);
+      this._pushTracksTask.schedule();
+    }
   }
 
-  private async _pullTrack(name: EncodedTrackName): Promise<void> {
+  private async _pullTrack(name: EncodedTrackName): Promise<{ shouldRetry: boolean }> {
     const ctx = this._ctx.derive();
     try {
       const trackData = TrackNameCodec.decode(name);
-      const track = await this._state.peer!.pullTrack({ trackData, ctx });
+      // We need to set mid here to `undefined`, because mid is peer specific.
+      const track = await this._state.peer!.pullTrack({ trackData: { ...trackData, mid: undefined }, ctx });
       if (track?.readyState === 'ended') {
         throw new Error('Pulled track ended immediately');
       }
@@ -299,7 +327,7 @@ export class MediaManager extends Resource {
         case 'audio': {
           this._state.pulledAudioTracks[name] = { track, ctx };
           ctx.onDispose(() => delete this._state.pulledAudioTracks[name]);
-          break;
+          return { shouldRetry: false };
         }
         case 'video': {
           const mediaStream = new MediaStream();
@@ -310,33 +338,41 @@ export class MediaManager extends Resource {
             track.stop();
             delete this._state.pulledVideoStreams[name];
           });
-          break;
+          return { shouldRetry: false };
         }
         default:
           throw new Error(`Invalid track kind: ${track?.kind}`);
       }
     } catch (err) {
-      log.verbose('failed to pull track', { err, name });
+      log.info('failed to pull track', { err, name });
       void ctx.dispose();
-      await cancelWithContext(this._ctx, sleep(RETRY_INTERVAL));
-      log.verbose('retrying pull track', { name });
-      this._pullTracksTask!.schedule();
+      return { shouldRetry: true };
     }
   }
 
-  private async _pushTrack(
+  private async _maybePushTrack(
     track?: MediaStreamTrack,
     previousTrack?: TrackObject,
     encodings?: RTCRtpEncodingParameters[],
-  ): Promise<TrackObject | undefined> {
+  ): Promise<{ track?: TrackObject; shouldRetry?: boolean }> {
     if (!track && !previousTrack) {
-      return;
+      return { track: undefined };
     }
 
-    return this._state.peer!.pushTrack({
-      track: track ?? null,
-      previousTrack,
-      encodings,
-    });
+    const ctx = this._ctx.derive();
+    try {
+      return {
+        track: await this._state.peer!.pushTrack({
+          ctx,
+          track: track ?? null,
+          previousTrack,
+          encodings,
+        }),
+      };
+    } catch (err) {
+      log.info('failed to push track', { err, track, previousTrack, encodings });
+      void ctx.dispose();
+      return { shouldRetry: true };
+    }
   }
 }

package/src/calls/types.ts

@@ -2,11 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
+import { invariant } from '@dxos/invariant';
 import { buf } from '@dxos/protocols/buf';
 import {
   type ActivitySchema,
-  UserStateSchema,
   type UserState as UserStateProto,
+  UserStateSchema,
 } from '@dxos/protocols/buf/dxos/edge/calls_pb';
 
 /**
@@ -61,10 +62,13 @@ export type EncodedTrackName = string & { __brand: 'EncodedTrackName' };
 
 export const TrackNameCodec = {
   encode: (trackData: TrackObject): EncodedTrackName => {
-    return (trackData.sessionId + '/' + trackData.trackName) as EncodedTrackName;
+    invariant(trackData.sessionId);
+    invariant(trackData.trackName);
+    invariant(trackData.mid);
+    return (trackData.sessionId + '/' + trackData.trackName + '/' + trackData.mid) as EncodedTrackName;
   },
   decode: (name: EncodedTrackName): TrackObject => {
-    const [sessionId, trackName] = name.split('/');
-    return { sessionId, trackName, location: 'remote' };
+    const [sessionId, trackName, mid] = name.split('/');
+    return { sessionId, trackName, location: 'remote', mid };
   },
 };