@dxos/plugin-thread 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/dist/lib/browser/chunk-ZE7KWN36.mjs

@@ -1,1669 +0,0 @@
-import {
-  createBlackCanvasStreamTrack,
-  createInaudibleAudioStreamTrack
-} from "./chunk-6NSMBO3B.mjs";
-
-// src/calls/types.ts
-import { buf } from "@dxos/protocols/buf";
-import { UserStateSchema } from "@dxos/protocols/buf/dxos/edge/calls_pb";
-var CALLS_URL = "https://calls-service.dxos.workers.dev";
-var codec = {
-  encode: (message) => {
-    return buf.toBinary(UserStateSchema, buf.create(UserStateSchema, message));
-  },
-  decode: (message) => {
-    return buf.fromBinary(UserStateSchema, message);
-  }
-};
-var TrackNameCodec = {
-  encode: (trackData) => {
-    return trackData.sessionId + "/" + trackData.trackName;
-  },
-  decode: (name) => {
-    const [sessionId, trackName] = name.split("/");
-    return {
-      sessionId,
-      trackName,
-      location: "remote"
-    };
-  }
-};
-
-// src/calls/call-swarm-synchronizer.ts
-import md5Hex from "md5-hex";
-import { DeferredTask, Event, scheduleTaskInterval, synchronized } from "@dxos/async";
-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 as buf2 } from "@dxos/protocols/buf";
-import { ActivitySchema } from "@dxos/protocols/buf/dxos/edge/calls_pb";
-import { ConnectionState } from "@dxos/protocols/proto/dxos/edge/messenger";
-import { isNonNullable } from "@dxos/util";
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/calls/call-swarm-synchronizer.ts";
-var DISCONNECTED_ABRUPT_TIMEOUT = 1e4;
-var CallSwarmSynchronizer = class extends Resource {
-  constructor({ networkService }) {
-    super();
-    this.stateUpdated = new Event();
-    this._state = {
-      activities: {}
-    };
-    this._lastSwarmEvent = void 0;
-    this._reconcileSwarmStateTask = void 0;
-    this._identityKey = void 0;
-    this._deviceKey = void 0;
-    this._displayName = void 0;
-    this._swarmCtx = void 0;
-    this._sendStateTask = void 0;
-    this._networkService = networkService;
-  }
-  /**
-  * @internal
-  */
-  _getState() {
-    return this._state;
-  }
-  setRaisedHand(raisedHand) {
-    if (this._state.raisedHand === raisedHand) {
-      return;
-    }
-    this._state.raisedHand = raisedHand;
-    this._notifyAndSchedule();
-  }
-  setSpeaking(speaking) {
-    if (this._state.speaking === speaking) {
-      return;
-    }
-    this._state.speaking = speaking;
-    this._notifyAndSchedule();
-  }
-  setJoined(joined) {
-    if (this._state.joined === joined) {
-      return;
-    }
-    this._state.joined = joined;
-    this._notifyAndSchedule();
-  }
-  setTracks(tracks) {
-    this._state.tracks = {
-      ...this._state.tracks,
-      ...tracks
-    };
-    this._notifyAndSchedule();
-  }
-  setActivity(key, payload) {
-    const lamportTimestamp = LamportTimestampCrdt.increment(this._state.activities?.[key]?.lamportTimestamp ?? {
-      id: this._deviceKey
-    });
-    this._state.activities[key] = {
-      lamportTimestamp,
-      payload
-    };
-    this._notifyAndSchedule();
-  }
-  /**
-  * @internal
-  */
-  _setIdentity(identity) {
-    this._identityKey = identity.identityKey.toHex();
-    this._displayName = identity.profile?.displayName ?? generateName(identity.identityKey.toHex());
-  }
-  /**
-  * @internal
-  */
-  _setDevice(device) {
-    this._deviceKey = device.deviceKey.toHex();
-  }
-  /**
-  * @internal
-  */
-  _setRoomId(roomId) {
-    if (this._swarmCtx) {
-      log.verbose("joined to a different room", {
-        roomId
-      }, {
-        F: __dxlog_file,
-        L: 152,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return;
-    }
-    this._state.roomId = roomId;
-  }
-  async _open() {
-    this._sendStateTask = new DeferredTask(this._ctx, async () => {
-      await this._sendState();
-    });
-    this._reconcileSwarmStateTask = new DeferredTask(this._ctx, async () => {
-      await this._reconcileSwarmState();
-    });
-  }
-  async _close() {
-    this._sendStateTask = void 0;
-    this._reconcileSwarmStateTask = void 0;
-  }
-  async join() {
-    invariant(this._state.roomId, void 0, {
-      F: __dxlog_file,
-      L: 176,
-      S: this,
-      A: [
-        "this._state.roomId",
-        ""
-      ]
-    });
-    invariant(!this._swarmCtx, "Already joined", {
-      F: __dxlog_file,
-      L: 177,
-      S: this,
-      A: [
-        "!this._swarmCtx",
-        "'Already joined'"
-      ]
-    });
-    this._swarmCtx = new Context(void 0, {
-      F: __dxlog_file,
-      L: 179
-    });
-    const topic = getTopic(this._state.roomId);
-    log("joining swarm", {
-      topic,
-      peer: {
-        identityKey: this._identityKey,
-        peerKey: this._deviceKey
-      }
-    }, {
-      F: __dxlog_file,
-      L: 181,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    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
-          }
-        }, {
-          F: __dxlog_file,
-          L: 188,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        void this._networkService.leaveSwarm({
-          topic,
-          peer: {
-            identityKey: this._identityKey,
-            peerKey: this._deviceKey
-          }
-        }).catch((err) => log.catch(err, void 0, {
-          F: __dxlog_file,
-          L: 194,
-          S: this,
-          C: (f, a) => f(...a)
-        }));
-      }
-      window.removeEventListener("beforeunload", cleanup);
-    };
-    window.addEventListener("beforeunload", cleanup);
-    this._swarmCtx.onDispose(cleanup);
-    this._notifyAndSchedule();
-  }
-  async leave() {
-    if (!this._swarmCtx) {
-      return;
-    }
-    await this._swarmCtx.dispose();
-    this._swarmCtx = void 0;
-    this._state.users = void 0;
-    this._state.self = void 0;
-  }
-  async querySwarm(roomId) {
-    const topic = getTopic(roomId);
-    const swarm = await this._networkService.querySwarm({
-      topic
-    });
-    return swarm.peers ?? [];
-  }
-  /**
-  * Notify and schedule send state task.
-  */
-  _notifyAndSchedule() {
-    this.stateUpdated.emit(this._state);
-    if (this._state.joined) {
-      this._sendStateTask?.schedule();
-    }
-  }
-  async _sendState() {
-    if (!this._state.roomId || !this._identityKey || !this._deviceKey || !this._state.joined) {
-      return;
-    }
-    const state = {
-      ...this._state,
-      id: this._deviceKey,
-      name: this._displayName,
-      activities: this._state.activities ? Object.fromEntries(Object.entries(this._state.activities).map(([key, activity]) => [
-        key,
-        buf2.create(ActivitySchema, activity)
-      ])) : {}
-    };
-    await this._networkService.joinSwarm({
-      topic: getTopic(this._state.roomId),
-      peer: {
-        identityKey: this._identityKey,
-        peerKey: this._deviceKey,
-        state: codec.encode(state)
-      }
-    });
-  }
-  _processSwarmEvent(swarmEvent) {
-    if (!this._state.joined) {
-      return;
-    }
-    this._lastSwarmEvent = swarmEvent;
-    this._reconcileSwarmStateTask.schedule();
-  }
-  async _reconcileSwarmState() {
-    const swarmEvent = this._lastSwarmEvent;
-    invariant(swarmEvent, void 0, {
-      F: __dxlog_file,
-      L: 273,
-      S: this,
-      A: [
-        "swarmEvent",
-        ""
-      ]
-    });
-    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
-        }, {
-          F: __dxlog_file,
-          L: 290,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        return void 0;
-      }
-    }).filter(isNonNullable);
-    this._state.users = users;
-    this._state.self = users.find((user) => user.id === this._deviceKey);
-    log("reconciling swarm state", {
-      users
-    }, {
-      F: __dxlog_file,
-      L: 297,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (users.length === 0) {
-      return;
-    }
-    const activityKeys = new Set(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);
-    if (peers.some((peer) => peer.connectionState !== ConnectionState.CONNECTED)) {
-      scheduleTaskInterval(this._ctx, async () => this._reconcileSwarmStateTask.schedule(), Math.min(DISCONNECTED_ABRUPT_TIMEOUT / 2, 1e3));
-    }
-  }
-};
-_ts_decorate([
-  synchronized
-], CallSwarmSynchronizer.prototype, "join", null);
-_ts_decorate([
-  synchronized
-], CallSwarmSynchronizer.prototype, "leave", null);
-var LamportTimestampCrdt = class {
-  static getLastState(states) {
-    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) {
-    return {
-      ...timestamp ?? {},
-      version: (timestamp?.version ?? 0) + 1
-    };
-  }
-};
-var getTopic = (roomId) => PublicKey.fromHex(md5Hex(roomId));
-
-// src/calls/util/audio.ts
-var monitorAudioLevel = ({ mediaStreamTrack, intervalMs = 1e3 / 10, onMeasure }) => {
-  let timeout = -1;
-  let interval = -1;
-  const audioContext = new AudioContext();
-  const stream = new MediaStream();
-  stream.addTrack(mediaStreamTrack);
-  const mediaStreamAudioSourceNode = audioContext.createMediaStreamSource(stream);
-  const analyserNode = audioContext.createAnalyser();
-  mediaStreamAudioSourceNode.connect(analyserNode);
-  analyserNode.fftSize = 32;
-  const pcmData = new Float32Array(analyserNode.fftSize);
-  let peak = 0;
-  interval = window.setInterval(() => {
-    onMeasure(peak);
-    peak = 0;
-  }, intervalMs);
-  const tick = () => {
-    timeout = window.setTimeout(() => {
-      analyserNode.getFloatTimeDomainData(pcmData);
-      let sumSquares = 0;
-      for (const amplitude of pcmData) {
-        sumSquares += amplitude * amplitude;
-      }
-      const current = Math.sqrt(sumSquares / pcmData.length);
-      if (current > peak) {
-        peak = current;
-      }
-      tick();
-    }, intervalMs);
-  };
-  tick();
-  return () => {
-    mediaStreamAudioSourceNode.disconnect();
-    analyserNode.disconnect();
-    void audioContext.close();
-    clearInterval(interval);
-    clearTimeout(timeout);
-    stream.removeTrack(mediaStreamTrack);
-  };
-};
-
-// src/calls/util/calls-service.ts
-import { PersistentLifecycle } from "@dxos/async";
-import { Resource as Resource2 } from "@dxos/context";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
-
-// src/calls/util/history-cache.ts
-var HistoryCache = class {
-  constructor(limit = 100) {
-    this._limit = limit;
-    this._messages = [];
-  }
-  push(...messages) {
-    if (this._messages.length >= this._limit) {
-      this._messages.shift();
-    }
-    this._messages.push(...messages);
-  }
-  get() {
-    return this._messages;
-  }
-};
-
-// src/calls/util/task-scheduling.ts
-var DefaultBatchSizeLimit = 64;
-var FIFOScheduler = class {
-  #schedulerChain;
-  constructor() {
-    this.#schedulerChain = Promise.resolve();
-  }
-  schedule(task) {
-    return new Promise((resolve, reject) => {
-      this.#schedulerChain = this.#schedulerChain.then(async () => {
-        try {
-          resolve(await task());
-        } catch (error) {
-          reject(error);
-        }
-      });
-    });
-  }
-};
-var BulkRequestDispatcher = class {
-  #currentBatch;
-  #currentBulkResponse;
-  #batchSizeLimit;
-  constructor(batchSizeLimit = DefaultBatchSizeLimit) {
-    this.#currentBatch = [];
-    this.#currentBulkResponse = null;
-    this.#batchSizeLimit = batchSizeLimit;
-  }
-  /**
-  * Returns a bulk response promise.
-  * At the event loop iteration end, the accumulated entries will be dispatched as a bulk request.
-  */
-  doBulkRequest(params, bulkRequestFunc) {
-    if (this.#currentBatch.length >= this.#batchSizeLimit) {
-      this.#currentBatch = [];
-      this.#currentBulkResponse = null;
-    }
-    this.#currentBatch.push(params);
-    if (this.#currentBulkResponse != null) {
-      return this.#currentBulkResponse;
-    }
-    const batch = this.#currentBatch;
-    this.#currentBulkResponse = new Promise((resolve, reject) => {
-      setTimeout(() => {
-        this.#currentBulkResponse = null;
-        const batchCopy = batch.splice(0, batch.length);
-        bulkRequestFunc(batchCopy).then((result) => {
-          resolve(result);
-        }).catch((err) => {
-          reject(err);
-        });
-      }, 0);
-    });
-    return this.#currentBulkResponse;
-  }
-};
-
-// src/calls/util/calls-service.ts
-var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/calls/util/calls-service.ts";
-var NETWORK_TIMEOUT = 5e3;
-var CallsServicePeer = class extends Resource2 {
-  constructor(config) {
-    super();
-    this.history = new HistoryCache(100);
-    this._persistentLifecycle = new PersistentLifecycle({
-      start: () => this._startSession(),
-      stop: (session) => this._stopSession(session)
-    });
-    this.taskScheduler = new FIFOScheduler();
-    this.pushTrackDispatcher = new BulkRequestDispatcher(32);
-    this.pullTrackDispatcher = new BulkRequestDispatcher(32);
-    this.closeTrackDispatcher = new BulkRequestDispatcher(32);
-    this._config = config;
-  }
-  async _open(ctx) {
-    await this._persistentLifecycle.open(ctx);
-  }
-  async _close() {
-    await this._persistentLifecycle.close();
-  }
-  get session() {
-    return this._persistentLifecycle.state;
-  }
-  async _startSession() {
-    const peerConnection = await this._createRtcConnection();
-    const sessionId = await this._initiateCallSession();
-    return {
-      sessionId,
-      peerConnection
-    };
-  }
-  async _stopSession(session) {
-    session.peerConnection.close();
-  }
-  async _createRtcConnection() {
-    const peerConnection = new RTCPeerConnection({
-      iceServers: this._config.iceServers,
-      bundlePolicy: "max-bundle"
-    });
-    peerConnection.addEventListener("connectionstatechange", () => {
-      if (peerConnection.connectionState === "failed" || peerConnection.connectionState === "closed") {
-        log2.warn("calls connection failed", {
-          state: peerConnection.connectionState
-        }, {
-          F: __dxlog_file2,
-          L: 118,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        void this._persistentLifecycle.scheduleRestart();
-      }
-    });
-    let iceTimeout = -1;
-    peerConnection.addEventListener("iceconnectionstatechange", () => {
-      clearTimeout(iceTimeout);
-      if (peerConnection.iceConnectionState === "failed" || peerConnection.iceConnectionState === "closed") {
-        log2.warn("calls connection to ICEs failed", {
-          state: peerConnection.iceConnectionState
-        }, {
-          F: __dxlog_file2,
-          L: 127,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        void this._persistentLifecycle.scheduleRestart();
-      } else if (peerConnection.iceConnectionState === "disconnected") {
-        const timeoutSeconds = 7;
-        iceTimeout = window.setTimeout(() => {
-          if (peerConnection.iceConnectionState === "connected") {
-            log2.info("calls iceConnectionState is connected", void 0, {
-              F: __dxlog_file2,
-              L: 136,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            return;
-          }
-          log2.warn("calls iceConnectionState timed out", {
-            state: peerConnection.iceConnectionState,
-            timeoutSeconds
-          }, {
-            F: __dxlog_file2,
-            L: 140,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          void this._persistentLifecycle.scheduleRestart();
-        }, timeoutSeconds * 1e3);
-      }
-    });
-    return peerConnection;
-  }
-  async _initiateCallSession() {
-    log2("creating new session", void 0, {
-      F: __dxlog_file2,
-      L: 150,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const { sessionId } = await this._fetch("/sessions/new?SESSION", {
-      method: "POST"
-    });
-    return sessionId;
-  }
-  async _fetch(relativePath, requestInit) {
-    this.history.push({
-      type: "request",
-      time: (/* @__PURE__ */ new Date()).toISOString(),
-      method: requestInit?.method ?? "GET",
-      body: requestInit?.body
-    });
-    const response = await fetch(`${this._config.apiBase}${relativePath}`, {
-      ...requestInit,
-      redirect: "manual"
-    });
-    if (response.status >= 400) {
-      log2.error("error while fetching from Calls service", {
-        status: response.status,
-        text: await response.text()
-      }, {
-        F: __dxlog_file2,
-        L: 165,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      throw new Error("Error while fetching from Calls service");
-    }
-    try {
-      const data = await response.clone().json();
-      this.history.push({
-        type: "response",
-        time: (/* @__PURE__ */ new Date()).toISOString(),
-        status: response.status,
-        json: data
-      });
-      if (data.errorCode) {
-        throw new Error(data.errorDescription);
-      }
-      return data;
-    } catch (error) {
-      const text = await response.text();
-      this.history.push({
-        type: "response",
-        time: (/* @__PURE__ */ new Date()).toISOString(),
-        status: response.status,
-        text
-      });
-      log2.error("Error parsing response from Calls service", {
-        error,
-        text,
-        status: response.status
-      }, {
-        F: __dxlog_file2,
-        L: 190,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      throw error;
-    }
-  }
-  async _pushTrackInBulk({ ctx, peerConnection, transceiver, sessionId, trackName }) {
-    log2.verbose("pushing track ", trackName, {
-      F: __dxlog_file2,
-      L: 212,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const pushedTrackPromise = this.pushTrackDispatcher.doBulkRequest({
-      trackName,
-      transceiver
-    }, (tracks) => this.taskScheduler.schedule(async () => {
-      const offer = await peerConnection.createOffer();
-      offer.sdp = offer.sdp?.replace("useinbandfec=1", "usedtx=1;useinbandfec=1");
-      await peerConnection.setLocalDescription(offer);
-      const response = await this._fetch(`/sessions/${sessionId}/tracks/new?PUSHING`, {
-        method: "POST",
-        body: JSON.stringify({
-          sessionDescription: {
-            sdp: offer.sdp,
-            type: "offer"
-          },
-          tracks: tracks.map(({ trackName: trackName2, transceiver: transceiver2 }) => ({
-            trackName: trackName2,
-            mid: transceiver2.mid,
-            location: "local"
-          }))
-        })
-      });
-      invariant2(response.tracks !== void 0, void 0, {
-        F: __dxlog_file2,
-        L: 237,
-        S: this,
-        A: [
-          "response.tracks !== undefined",
-          ""
-        ]
-      });
-      if (!response.errorCode) {
-        await peerConnection.setRemoteDescription(new RTCSessionDescription(response.sessionDescription));
-        await peerConnectionIsConnected(peerConnection);
-      }
-      return {
-        tracks: response.tracks
-      };
-    })).then(({ tracks }) => {
-      const trackData = tracks.find((t) => t.mid === transceiver.mid);
-      if (trackData) {
-        return {
-          ...trackData,
-          sessionId,
-          location: "remote"
-        };
-      } else {
-        log2.error("missing track data", void 0, {
-          F: __dxlog_file2,
-          L: 257,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    }).catch((err) => {
-      log2.catch(err, void 0, {
-        F: __dxlog_file2,
-        L: 261,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    });
-    const onDispose = async () => {
-      if (transceiver.mid) {
-        await this._closeTrackInBulk(peerConnection, transceiver.mid, sessionId);
-      }
-    };
-    ctx?.onDispose(async () => await onDispose());
-    this._ctx.onDispose(() => onDispose());
-    return pushedTrackPromise;
-  }
-  async pushTrack({ track, encodings = [], ctx, previousTrack }) {
-    await this.waitUntilOpen();
-    invariant2(this.session, void 0, {
-      F: __dxlog_file2,
-      L: 288,
-      S: this,
-      A: [
-        "this.session",
-        ""
-      ]
-    });
-    log2("trying to push track", {
-      track,
-      previousTrack,
-      encodings
-    }, {
-      F: __dxlog_file2,
-      L: 289,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (previousTrack) {
-      const transceiver2 = this.session.peerConnection.getTransceivers().find((t) => t.mid === previousTrack.mid);
-      if (transceiver2?.sender.track === track) {
-        log2.verbose("track already pushed", {
-          track,
-          previousTrack,
-          transceiver: transceiver2
-        }, {
-          F: __dxlog_file2,
-          L: 293,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        return previousTrack;
-      } else if (transceiver2) {
-        log2.verbose("replacing track", {
-          track,
-          previousTrack,
-          transceiver: transceiver2
-        }, {
-          F: __dxlog_file2,
-          L: 296,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        transceiver2.sender.replaceTrack(track).catch((err) => log2.catch(err, void 0, {
-          F: __dxlog_file2,
-          L: 297,
-          S: this,
-          C: (f, a) => f(...a)
-        }));
-        return previousTrack;
-      }
-    }
-    invariant2(track, void 0, {
-      F: __dxlog_file2,
-      L: 301,
-      S: this,
-      A: [
-        "track",
-        ""
-      ]
-    });
-    const stableId = crypto.randomUUID();
-    const transceiver = this.session.peerConnection.addTransceiver(track, {
-      direction: "sendonly"
-    });
-    log2.verbose("creating transceiver", void 0, {
-      F: __dxlog_file2,
-      L: 306,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const pushedTrackData = await this._pushTrackInBulk({
-      ctx,
-      peerConnection: this.session.peerConnection,
-      transceiver,
-      sessionId: this.session.sessionId,
-      trackName: stableId
-    });
-    invariant2(pushedTrackData, void 0, {
-      F: __dxlog_file2,
-      L: 315,
-      S: this,
-      A: [
-        "pushedTrackData",
-        ""
-      ]
-    });
-    const parameters = transceiver.sender.getParameters();
-    encodings.forEach((encoding, i) => {
-      const existing = parameters.encodings[i];
-      parameters.encodings[i] = {
-        ...existing,
-        ...encoding
-      };
-    });
-    transceiver.sender.setParameters(parameters).catch((err) => log2.catch(err, void 0, {
-      F: __dxlog_file2,
-      L: 322,
-      S: this,
-      C: (f, a) => f(...a)
-    }));
-    return pushedTrackData;
-  }
-  // TODO(mykola): Add retry logic if the tracks fails to pull.
-  async _pullTrackInBulk({ peerConnection, sessionId, trackData, ctx }) {
-    let mid = "";
-    log2("pulling track", {
-      trackName: trackData.trackName
-    }, {
-      F: __dxlog_file2,
-      L: 340,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const pulledTrackPromise = this.pullTrackDispatcher.doBulkRequest(trackData, (tracks) => this.taskScheduler.schedule(async () => {
-      const newTrackResponse = await this._fetch(`/sessions/${sessionId}/tracks/new?PULLING`, {
-        method: "POST",
-        body: JSON.stringify({
-          tracks
-        })
-      });
-      if (newTrackResponse.errorCode) {
-        throw new Error(newTrackResponse.errorDescription);
-      }
-      invariant2(newTrackResponse.tracks, void 0, {
-        F: __dxlog_file2,
-        L: 353,
-        S: this,
-        A: [
-          "newTrackResponse.tracks",
-          ""
-        ]
-      });
-      const trackMap = tracks.reduce((acc, track) => {
-        const pulledTrackData = newTrackResponse.tracks?.find((t) => t.trackName === track.trackName && t.sessionId === track.sessionId);
-        if (pulledTrackData && pulledTrackData.mid) {
-          acc.set(track.trackName, {
-            mid: pulledTrackData.mid,
-            resolvedTrack: resolveTrack(peerConnection, (t) => t.mid === pulledTrackData.mid)
-          });
-        }
-        return acc;
-      }, /* @__PURE__ */ new Map());
-      if (newTrackResponse.requiresImmediateRenegotiation) {
-        await peerConnection.setRemoteDescription(new RTCSessionDescription(newTrackResponse.sessionDescription));
-        const answer = await peerConnection.createAnswer();
-        await peerConnection.setLocalDescription(answer);
-        const renegotiationResponse = await this._fetch(`/sessions/${sessionId}/renegotiate`, {
-          method: "PUT",
-          body: JSON.stringify({
-            sessionDescription: {
-              type: "answer",
-              sdp: peerConnection.currentLocalDescription?.sdp
-            }
-          })
-        });
-        if (renegotiationResponse.errorCode) {
-          throw new Error(renegotiationResponse.errorDescription);
-        } else {
-          await peerConnectionIsConnected(peerConnection);
-        }
-      }
-      return {
-        trackMap
-      };
-    })).then(({ trackMap }) => {
-      const trackInfo = trackMap.get(trackData.trackName);
-      if (trackInfo) {
-        return trackInfo.resolvedTrack.then((track) => {
-          mid = trackInfo.mid;
-          return track;
-        }).catch((err) => log2.catch(err, void 0, {
-          F: __dxlog_file2,
-          L: 405,
-          S: this,
-          C: (f, a) => f(...a)
-        }));
-      } else {
-        log2.warn("missing track info", {
-          trackData,
-          availableTracks: Array.from(trackMap.keys())
-        }, {
-          F: __dxlog_file2,
-          L: 407,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    });
-    const onDispose = async () => {
-      if (mid) {
-        log2("closing pulled track ", trackData.trackName, {
-          F: __dxlog_file2,
-          L: 413,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        await this._closeTrackInBulk(peerConnection, mid, sessionId);
-        mid = "";
-      }
-    };
-    this._ctx.onDispose(() => onDispose());
-    ctx?.onDispose(() => onDispose());
-    return pulledTrackPromise;
-  }
-  async pullTrack({ ctx, trackData }) {
-    await this.waitUntilOpen();
-    invariant2(this.session, void 0, {
-      F: __dxlog_file2,
-      L: 434,
-      S: this,
-      A: [
-        "this.session",
-        ""
-      ]
-    });
-    const session = this.session;
-    return this._pullTrackInBulk({
-      peerConnection: session.peerConnection,
-      sessionId: session.sessionId,
-      trackData,
-      ctx
-    });
-  }
-  async _closeTrackInBulk(peerConnection, mid, sessionId) {
-    const transceiver = peerConnection.getTransceivers().find((t) => t.mid === mid);
-    if (peerConnection.connectionState !== "connected" || transceiver === void 0) {
-      return;
-    }
-    await this.closeTrackDispatcher.doBulkRequest({
-      mid
-    }, (mids) => this.taskScheduler.schedule(async () => {
-      transceiver.stop();
-      const activeTransceivers = peerConnection.getTransceivers().filter((t) => t.mid !== mid && t.direction !== "stopped");
-      let requestBody;
-      if (activeTransceivers.length > 0) {
-        const offer = await peerConnection.createOffer();
-        await peerConnection.setLocalDescription(offer);
-        requestBody = {
-          tracks: mids,
-          sessionDescription: {
-            sdp: peerConnection.localDescription?.sdp,
-            type: "offer"
-          },
-          force: false
-        };
-      } else {
-        requestBody = {
-          tracks: mids,
-          force: true
-        };
-      }
-      const response = await this._fetch(`/sessions/${sessionId}/tracks/close`, {
-        method: "PUT",
-        body: JSON.stringify(requestBody)
-      });
-      if (requestBody.sessionDescription) {
-        await peerConnection.setRemoteDescription(new RTCSessionDescription(response.sessionDescription));
-      }
-    }));
-  }
-};
-var resolveTrack = async (peerConnection, compare, timeout = NETWORK_TIMEOUT) => new Promise((resolve, reject) => {
-  setTimeout(reject, timeout);
-  const handler = () => {
-    const transceiver = peerConnection.getTransceivers().find(compare);
-    if (transceiver) {
-      resolve(transceiver.receiver.track);
-      peerConnection.removeEventListener("track", handler);
-    }
-  };
-  peerConnection.addEventListener("track", handler);
-});
-var peerConnectionIsConnected = async (peerConnection) => {
-  if (peerConnection.connectionState !== "connected") {
-    const connected = new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        peerConnection.removeEventListener("connectionstatechange", connectionStateChangeHandler);
-        reject(new Error("Connection timeout"));
-      }, NETWORK_TIMEOUT);
-      const connectionStateChangeHandler = () => {
-        if (peerConnection.connectionState === "connected") {
-          peerConnection.removeEventListener("connectionstatechange", connectionStateChangeHandler);
-          clearTimeout(timeout);
-          resolve(void 0);
-        }
-      };
-      peerConnection.addEventListener("connectionstatechange", connectionStateChangeHandler);
-    });
-    await connected;
-  }
-};
-
-// src/calls/util/media.ts
-import { log as log3 } from "@dxos/log";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/calls/util/media.ts";
-var getUserMediaTrack = async (kind, constraints = {}, deviceList) => {
-  deviceList ??= (await getDeviceList()).filter((device) => device.kind === kind);
-  const firstDevice = deviceList[0];
-  if (!firstDevice) {
-    throw new Error("No devices found");
-  }
-  return acquireTrack(firstDevice, constraints);
-};
-var acquireTrack = async (device, constraints) => {
-  const { deviceId, label } = device;
-  log3.info(`requesting ${label}`, void 0, {
-    F: __dxlog_file3,
-    L: 23,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
-  const mediaStream = await navigator.mediaDevices.getUserMedia(device.kind === "videoinput" ? {
-    video: {
-      ...constraints,
-      deviceId
-    }
-  } : {
-    audio: {
-      ...constraints,
-      deviceId
-    }
-  });
-  return device.kind === "videoinput" ? mediaStream.getVideoTracks()[0] : mediaStream.getAudioTracks()[0];
-};
-var getDeviceList = () => navigator.mediaDevices.enumerateDevices();
-var SCREENSHARE_CONSTRAINTS = {
-  video: {
-    width: {
-      max: 1920
-    },
-    height: {
-      max: 1080
-    },
-    frameRate: {
-      max: 10
-    }
-  }
-};
-var getScreenshare = async ({ contentHint }) => {
-  const ms = await navigator.mediaDevices.getDisplayMedia(SCREENSHARE_CONSTRAINTS);
-  ms.getVideoTracks().forEach((track) => {
-    if (contentHint && "contentHint" in track) {
-      track.contentHint = contentHint;
-    }
-  });
-  return ms;
-};
-
-// src/calls/speaking-monitor.ts
-import { DeferredTask as DeferredTask2, Event as Event2, sleep } from "@dxos/async";
-import { Resource as Resource3 } from "@dxos/context";
-var NOT_SPEAKING_AFTER = 500;
-var START_SPEAKING_THRESHOLD = 0.05;
-var CONTINUE_SPEAKING_THRESHOLD = 0.02;
-var MIN_EVENT_INTERVAL = 100;
-var SpeakingMonitor = class extends Resource3 {
-  constructor(_mediaStreamTrack) {
-    super(), this._mediaStreamTrack = _mediaStreamTrack, this.speakingChanged = new Event2(), this._isSpeaking = false, this._lastEventTime = 0;
-  }
-  get isSpeaking() {
-    return this._isSpeaking;
-  }
-  async _open() {
-    this._deferredUpdate = new DeferredTask2(this._ctx, async () => this._emitSpeakingChanged());
-    let timeout;
-    const cleanup = monitorAudioLevel({
-      mediaStreamTrack: this._mediaStreamTrack,
-      onMeasure: (vol) => {
-        const audioLevelAboveThreshold = vol > (this._isSpeaking ? CONTINUE_SPEAKING_THRESHOLD : START_SPEAKING_THRESHOLD);
-        if (audioLevelAboveThreshold) {
-          clearTimeout(timeout);
-          timeout = void 0;
-          if (!this._isSpeaking) {
-            this._isSpeaking = true;
-            this._deferredUpdate?.schedule();
-          }
-        } else if (timeout === void 0) {
-          timeout = setTimeout(() => {
-            this._isSpeaking = false;
-            timeout = void 0;
-            this._deferredUpdate?.schedule();
-          }, NOT_SPEAKING_AFTER);
-        }
-      }
-    });
-    this._ctx.onDispose(() => {
-      cleanup();
-      clearTimeout(timeout);
-    });
-  }
-  /**
-  * Emits the speaking changed event with debouncing based on timing.
-  */
-  async _emitSpeakingChanged() {
-    const timeSinceLastEvent = Date.now() - this._lastEventTime;
-    const timeToNextEvent = MIN_EVENT_INTERVAL - timeSinceLastEvent;
-    if (timeToNextEvent > 0) {
-      await sleep(timeToNextEvent);
-    }
-    this._lastEventTime = Date.now();
-    this.speakingChanged.emit(this._isSpeaking);
-  }
-};
-
-// src/calls/media-manager.ts
-import { DeferredTask as DeferredTask3, Event as Event3, sleep as sleep2, synchronized as synchronized2 } from "@dxos/async";
-import { cancelWithContext, Resource as Resource4 } from "@dxos/context";
-import { log as log4 } from "@dxos/log";
-function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file4 = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/calls/media-manager.ts";
-var VIDEO_WIDTH = 1280;
-var VIDEO_HEIGHT = 720;
-var MAX_WEB_CAM_FRAMERATE = 24;
-var MAX_WEB_CAM_BITRATE = 12e5;
-var RETRY_INTERVAL = 500;
-var USE_INAUDIBLE_AUDIO = false;
-var MediaManager = class extends Resource4 {
-  constructor() {
-    super(...arguments);
-    this.stateUpdated = new Event3();
-    this._state = {
-      pulledVideoStreams: {},
-      pulledAudioTracks: {}
-    };
-    this._speakingMonitor = void 0;
-    this._trackToReconcile = [];
-    this._blackCanvasStreamTrack = void 0;
-    this._inaudibleAudioStreamTrack = void 0;
-    this._pushTracksTask = void 0;
-    this._pullTracksTask = void 0;
-  }
-  get isSpeaking() {
-    return this._speakingMonitor?.isSpeaking;
-  }
-  /**
-  * @internal
-  */
-  _getState() {
-    return this._state;
-  }
-  async _open() {
-    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);
-    if (USE_INAUDIBLE_AUDIO) {
-      this._inaudibleAudioStreamTrack = await createInaudibleAudioStreamTrack({
-        ctx: this._ctx
-      });
-      this._state.audioTrack = this._inaudibleAudioStreamTrack;
-    }
-    this._pushTracksTask = new DeferredTask3(this._ctx, async () => {
-      await this._pushTracks();
-    });
-    this._pullTracksTask = new DeferredTask3(this._ctx, async () => {
-      await this._reconcilePulledMedia();
-    });
-  }
-  async _close() {
-    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 = void 0;
-    this._pullTracksTask = void 0;
-  }
-  async join(serviceConfig) {
-    this._state.peer = new CallsServicePeer(serviceConfig);
-    await this._state.peer.open();
-    this._pushTracksTask.schedule();
-  }
-  async leave() {
-    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 = void 0;
-    this._state.pushedVideoTrack = void 0;
-    this._state.pushedAudioTrack = void 0;
-    this._state.pushedScreenshareTrack = void 0;
-    this._state.pulledAudioTracks = {};
-    this._state.pulledVideoStreams = {};
-  }
-  async turnVideoOn() {
-    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() {
-    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() {
-    void this._speakingMonitor?.close();
-    this._state.audioEnabled = true;
-    this._state.audioTrack = await getUserMediaTrack("audioinput", {
-      echoCancellation: true,
-      noiseSuppression: true,
-      autoGainControl: true,
-      sampleRate: 16e3
-    });
-    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() {
-    void this._speakingMonitor?.close();
-    this._speakingMonitor = void 0;
-    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 = void 0;
-    }
-    this.stateUpdated.emit(this._state);
-    this._pushTracksTask.schedule();
-  }
-  async turnScreenshareOn() {
-    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() {
-    this._state.screenshareEnabled = false;
-    this._state.screenshareTrack?.stop();
-    this._state.screenshareTrack = void 0;
-    this.stateUpdated.emit(this._state);
-    this._pushTracksTask.schedule();
-  }
-  /**
-  * @internal
-  */
-  _schedulePullTracks(tracks) {
-    if (!tracks || this._trackToReconcile.every((name) => tracks.includes(name)) && this._trackToReconcile.length === tracks.length) {
-      return;
-    }
-    this._trackToReconcile = tracks;
-    this._pullTracksTask.schedule();
-  }
-  async _reconcilePulledMedia() {
-    log4("reconciling tracks", void 0, {
-      F: __dxlog_file4,
-      L: 222,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await cancelWithContext(this._ctx, sleep2(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));
-    log4("reconciling tracks", {
-      trackNames,
-      tracksToPull,
-      videoStreamsToClose,
-      audioTracksToClose,
-      currentAudioTracks: Object.keys(this._state.pulledAudioTracks),
-      currentVideoStreams: Object.keys(this._state.pulledVideoStreams)
-    }, {
-      F: __dxlog_file4,
-      L: 241,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await Promise.all(tracksToPull.map((name) => this._pullTrack(name)));
-    await Promise.all([
-      ...audioTracksToClose,
-      ...videoStreamsToClose
-    ].map(([_, { ctx }]) => ctx.dispose()));
-    log4("reconciled tracks", {
-      currentAudioTracks: Object.keys(this._state.pulledAudioTracks),
-      currentVideoStreams: Object.keys(this._state.pulledVideoStreams)
-    }, {
-      F: __dxlog_file4,
-      L: 256,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this.stateUpdated.emit(this._state);
-  }
-  async _pushTracks() {
-    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);
-  }
-  async _pullTrack(name) {
-    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) {
-      log4.verbose("failed to pull track", {
-        err,
-        name
-      }, {
-        F: __dxlog_file4,
-        L: 326,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      void ctx.dispose();
-      await cancelWithContext(this._ctx, sleep2(RETRY_INTERVAL));
-      log4.verbose("retrying pull track", {
-        name
-      }, {
-        F: __dxlog_file4,
-        L: 329,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._pullTracksTask.schedule();
-    }
-  }
-  async _pushTrack(track, previousTrack, encodings) {
-    if (!track && !previousTrack) {
-      return;
-    }
-    return this._state.peer.pushTrack({
-      track: track ?? null,
-      previousTrack,
-      encodings
-    });
-  }
-};
-_ts_decorate2([
-  synchronized2
-], MediaManager.prototype, "join", null);
-_ts_decorate2([
-  synchronized2
-], MediaManager.prototype, "leave", null);
-
-// src/calls/call-manager.ts
-import { computed } from "@preact/signals-core";
-import { Event as Event4, synchronized as synchronized3 } from "@dxos/async";
-import { Resource as Resource5 } from "@dxos/context";
-import { invariant as invariant3 } from "@dxos/invariant";
-import { live } from "@dxos/live-object";
-import { isNonNullable as isNonNullable2 } from "@dxos/util";
-function _ts_decorate3(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file5 = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/calls/call-manager.ts";
-var CallManager = class extends Resource5 {
-  /** @reactive */
-  get roomId() {
-    return this._state.call.roomId;
-  }
-  /** @reactive */
-  get raisedHand() {
-    return this._raisedHandSignal.value;
-  }
-  /** @reactive */
-  get speaking() {
-    return this._speakingSignal.value;
-  }
-  /** @reactive */
-  get joined() {
-    return this._joinedSignal.value;
-  }
-  /** @reactive */
-  get self() {
-    return this._state.call.self ?? {};
-  }
-  /** @reactive */
-  get tracks() {
-    return this._state.call.tracks ?? {};
-  }
-  /** @reactive */
-  get users() {
-    return this._state.call.users ?? [];
-  }
-  /** @reactive */
-  get media() {
-    return this._state.media;
-  }
-  /** @reactive */
-  get audioTracksToPlay() {
-    return (this._state.call.users ?? []).map((user) => user.tracks?.audioEnabled ? user.tracks?.audio : void 0).filter(isNonNullable2).map((track) => this._state.media.pulledAudioTracks[track]?.track).filter(isNonNullable2);
-  }
-  /** @reactive */
-  get state() {
-    return this._state;
-  }
-  /** @reactive */
-  getVideoStream(name) {
-    return name ? this._state.media.pulledVideoStreams[name]?.stream : void 0;
-  }
-  /** @reactive */
-  getActivity(key) {
-    return this._state.call.activities?.[key];
-  }
-  setRoomId(roomId) {
-    this._swarmSynchronizer._setRoomId(roomId);
-  }
-  setSpeaking(speaking) {
-    this._swarmSynchronizer.setSpeaking(speaking);
-  }
-  setRaisedHand(raisedHand) {
-    this._swarmSynchronizer.setRaisedHand(raisedHand);
-  }
-  setActivity(key, payload) {
-    this._swarmSynchronizer.setActivity(key, payload);
-  }
-  turnAudioOn() {
-    return this._mediaManager.turnAudioOn();
-  }
-  turnAudioOff() {
-    return this._mediaManager.turnAudioOff();
-  }
-  turnVideoOn() {
-    return this._mediaManager.turnVideoOn();
-  }
-  turnVideoOff() {
-    return this._mediaManager.turnVideoOff();
-  }
-  turnScreenshareOn() {
-    return this._mediaManager.turnScreenshareOn();
-  }
-  turnScreenshareOff() {
-    return this._mediaManager.turnScreenshareOff();
-  }
-  // TODO(burdon): Can this be mocked?
-  constructor(_client) {
-    super(), this._client = _client, this.callStateUpdated = new Event4(), this.mediaStateUpdated = new Event4(), this.left = new Event4(), this._state = live({
-      call: {},
-      media: {
-        pulledAudioTracks: {},
-        pulledVideoStreams: {}
-      }
-    }), this._raisedHandSignal = computed(() => this._state.call.raisedHand ?? false), this._speakingSignal = computed(() => this._state.call.speaking ?? false), this._joinedSignal = computed(() => this._state.call.joined ?? false);
-    this._client.config.getOrThrow("runtime.services.edge.url");
-    const networkService = this._client.services.services.NetworkService;
-    invariant3(networkService, "network service not found", {
-      F: __dxlog_file5,
-      L: 159,
-      S: this,
-      A: [
-        "networkService",
-        "'network service not found'"
-      ]
-    });
-    this._swarmSynchronizer = new CallSwarmSynchronizer({
-      networkService
-    });
-    this._mediaManager = new MediaManager();
-  }
-  async _open() {
-    await this._mediaManager.open();
-    await this._swarmSynchronizer.open();
-    const subscription = this._client.halo.identity.subscribe((identity) => {
-      if (identity) {
-        this._swarmSynchronizer._setIdentity(identity);
-      }
-      if (this._client.halo.device) {
-        this._swarmSynchronizer._setDevice(this._client.halo.device);
-      }
-    });
-    this._ctx.onDispose(() => subscription.unsubscribe());
-    this._swarmSynchronizer.stateUpdated.on(this._ctx, (state) => this._onCallStateUpdated(state));
-    this._mediaManager.stateUpdated.on(this._ctx, (state) => this._onMediaStateUpdated(state));
-  }
-  async _close() {
-    await this._swarmSynchronizer.leave();
-    await this._swarmSynchronizer.close();
-    await this._mediaManager.close();
-  }
-  async peek(roomId) {
-    const peers = await this._swarmSynchronizer.querySwarm(roomId);
-    return peers.length;
-  }
-  // TODO(mykola): Reconcile with _swarmSynchronizer.state.joined.
-  async join() {
-    this._swarmSynchronizer.setJoined(true);
-    await this._swarmSynchronizer.join();
-    await this._mediaManager.join({
-      iceServers: this._client.config.get("runtime.services.ice"),
-      apiBase: `${CALLS_URL}/api/calls`
-    });
-  }
-  async leave() {
-    this._swarmSynchronizer.setJoined(false);
-    await this._swarmSynchronizer.leave();
-    await this._mediaManager.leave();
-    this.roomId && this.left.emit(this.roomId);
-  }
-  _onCallStateUpdated(state) {
-    const tracksToPull = state.users?.filter((user) => user.joined && user.id !== state.self?.id)?.flatMap((user) => [
-      user.tracks?.video,
-      user.tracks?.audio,
-      user.tracks?.screenshare
-    ]).filter(isNonNullable2);
-    this._mediaManager._schedulePullTracks(tracksToPull);
-    this.callStateUpdated.emit(state);
-    this._updateState();
-  }
-  _onMediaStateUpdated(state) {
-    this._swarmSynchronizer.setTracks({
-      video: state.pushedVideoTrack ? TrackNameCodec.encode(state.pushedVideoTrack) : void 0,
-      audio: state.pushedAudioTrack ? TrackNameCodec.encode(state.pushedAudioTrack) : void 0,
-      screenshare: state.pushedScreenshareTrack ? TrackNameCodec.encode(state.pushedScreenshareTrack) : void 0,
-      videoEnabled: state.videoEnabled,
-      audioEnabled: state.audioEnabled,
-      screenshareEnabled: state.screenshareEnabled
-    });
-    const isSpeaking = this._mediaManager.isSpeaking ?? false;
-    this._swarmSynchronizer.setSpeaking(isSpeaking);
-    this.mediaStateUpdated.emit([
-      state,
-      isSpeaking
-    ]);
-    this._updateState();
-  }
-  /**
-  * Only this method is allowed to change state.
-  */
-  _updateState() {
-    this._state.call = this._swarmSynchronizer._getState();
-    this._state.media = this._mediaManager._getState();
-  }
-};
-_ts_decorate3([
-  synchronized3
-], CallManager.prototype, "join", null);
-_ts_decorate3([
-  synchronized3
-], CallManager.prototype, "leave", null);
-
-export {
-  CALLS_URL,
-  codec,
-  TrackNameCodec,
-  CallSwarmSynchronizer,
-  monitorAudioLevel,
-  CallsServicePeer,
-  getUserMediaTrack,
-  getDeviceList,
-  getScreenshare,
-  SpeakingMonitor,
-  MediaManager,
-  CallManager
-};
-//# sourceMappingURL=chunk-ZE7KWN36.mjs.map