@dxos/plugin-thread 0.8.4-main.74a063c4e0 → 0.8.4-main.765dc60934

package/dist/lib/browser/index.mjs

@@ -1,2334 +0,0 @@
-import {
-  ThreadCapabilities
-} from "./chunk-7T7J6ZR6.mjs";
-import "./chunk-J5LGTIGS.mjs";
-
-// src/calls/call-manager.ts
-import { Atom } from "@effect-atom/atom-react";
-import { Event as Event4, synchronized as synchronized3 } from "@dxos/async";
-import { Resource as Resource5 } from "@dxos/context";
-import { invariant as invariant6 } from "@dxos/invariant";
-import { isNonNullable as isNonNullable2 } from "@dxos/util";
-
-// 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 as invariant2 } 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";
-
-// src/calls/types.ts
-import { invariant } from "@dxos/invariant";
-import { buf } from "@dxos/protocols/buf";
-import { UserStateSchema } from "@dxos/protocols/buf/dxos/edge/calls_pb";
-var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/calls/types.ts";
-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) => {
-    invariant(trackData.sessionId, void 0, {
-      F: __dxlog_file,
-      L: 65,
-      S: void 0,
-      A: [
-        "trackData.sessionId",
-        ""
-      ]
-    });
-    invariant(trackData.trackName, void 0, {
-      F: __dxlog_file,
-      L: 66,
-      S: void 0,
-      A: [
-        "trackData.trackName",
-        ""
-      ]
-    });
-    invariant(trackData.mid, void 0, {
-      F: __dxlog_file,
-      L: 67,
-      S: void 0,
-      A: [
-        "trackData.mid",
-        ""
-      ]
-    });
-    return trackData.sessionId + "/" + trackData.trackName + "/" + trackData.mid;
-  },
-  decode: (name) => {
-    const [sessionId, trackName, mid] = name.split("/");
-    return {
-      sessionId,
-      trackName,
-      location: "remote",
-      mid
-    };
-  }
-};
-
-// src/calls/call-swarm-synchronizer.ts
-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_file2 = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/calls/call-swarm-synchronizer.ts";
-var DISCONNECTED_ABRUPT_TIMEOUT = 1e4;
-var CallSwarmSynchronizer = class extends Resource {
-  stateUpdated = new Event();
-  _state = {
-    activities: {}
-  };
-  _networkService;
-  _lastSwarmEvent = void 0;
-  _reconcileSwarmStateTask = void 0;
-  _identityKey = void 0;
-  _deviceKey = void 0;
-  _displayName = void 0;
-  _swarmCtx = void 0;
-  _sendStateTask = void 0;
-  constructor({ networkService }) {
-    super();
-    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_file2,
-        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() {
-    invariant2(this._state.roomId, void 0, {
-      F: __dxlog_file2,
-      L: 176,
-      S: this,
-      A: [
-        "this._state.roomId",
-        ""
-      ]
-    });
-    invariant2(!this._swarmCtx, "Already joined", {
-      F: __dxlog_file2,
-      L: 177,
-      S: this,
-      A: [
-        "!this._swarmCtx",
-        "'Already joined'"
-      ]
-    });
-    this._swarmCtx = new Context(void 0, {
-      F: __dxlog_file2,
-      L: 179
-    });
-    const topic = getTopic(this._state.roomId);
-    log("joining swarm", {
-      topic,
-      peer: {
-        identityKey: this._identityKey,
-        peerKey: this._deviceKey
-      }
-    }, {
-      F: __dxlog_file2,
-      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_file2,
-          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_file2,
-          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;
-    invariant2(swarmEvent, void 0, {
-      F: __dxlog_file2,
-      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_file2,
-          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_file2,
-      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/media-manager.ts
-import { DeferredTask as DeferredTask3, Event as Event3, sleep as sleep2, synchronized as synchronized2 } from "@dxos/async";
-import { Resource as Resource4, cancelWithContext as cancelWithContext2 } from "@dxos/context";
-import { invariant as invariant5 } from "@dxos/invariant";
-import { log as log4 } from "@dxos/log";
-
-// src/calls/speaking-monitor.ts
-import { DeferredTask as DeferredTask2, Event as Event2, sleep } from "@dxos/async";
-import { Resource as Resource3 } from "@dxos/context";
-
-// 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, Trigger, scheduleTask } from "@dxos/async";
-import { Resource as Resource2 } from "@dxos/context";
-import { invariant as invariant3 } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
-
-// src/calls/util/history-cache.ts
-var HistoryCache = class {
-  _limit;
-  _messages;
-  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_file3 = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/calls/util/calls-service.ts";
-var NETWORK_TIMEOUT = 5e3;
-var CallsServicePeer = class extends Resource2 {
-  history = new HistoryCache(100);
-  _persistentLifecycle = new PersistentLifecycle({
-    start: () => this._startSession(),
-    stop: (session) => this._stopSession(session)
-  });
-  _config;
-  taskScheduler = new FIFOScheduler();
-  pushTrackDispatcher = new BulkRequestDispatcher(32);
-  pullTrackDispatcher = new BulkRequestDispatcher(32);
-  closeTrackDispatcher = new BulkRequestDispatcher(32);
-  constructor(config) {
-    super();
-    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.info("calls connection failed", {
-          state: peerConnection.connectionState
-        }, {
-          F: __dxlog_file3,
-          L: 120,
-          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.info("calls connection to ICEs failed", {
-          state: peerConnection.iceConnectionState
-        }, {
-          F: __dxlog_file3,
-          L: 129,
-          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_file3,
-              L: 138,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            return;
-          }
-          log2.info("calls iceConnectionState timed out", {
-            state: peerConnection.iceConnectionState,
-            timeoutSeconds
-          }, {
-            F: __dxlog_file3,
-            L: 142,
-            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_file3,
-      L: 152,
-      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({
-      endpoint: relativePath,
-      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_file3,
-        L: 168,
-        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({
-        endpoint: relativePath,
-        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({
-        endpoint: relativePath,
-        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_file3,
-        L: 195,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      throw error;
-    }
-  }
-  async _pushTrackInBulk({ ctx, peerConnection, transceiver, sessionId, trackName }) {
-    log2.verbose("pushing track ", trackName, {
-      F: __dxlog_file3,
-      L: 217,
-      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"
-          }))
-        })
-      });
-      invariant3(response.tracks !== void 0, void 0, {
-        F: __dxlog_file3,
-        L: 242,
-        S: this,
-        A: [
-          "response.tracks !== undefined",
-          ""
-        ]
-      });
-      if (!response.errorCode) {
-        await peerConnection.setRemoteDescription(new RTCSessionDescription(response.sessionDescription));
-        await peerConnectionIsConnected(peerConnection);
-      }
-      return {
-        tracks: response.tracks
-      };
-    })).then(async ({ 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_file3,
-          L: 266,
-          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();
-    invariant3(this.session, void 0, {
-      F: __dxlog_file3,
-      L: 294,
-      S: this,
-      A: [
-        "this.session",
-        ""
-      ]
-    });
-    log2("trying to push track", {
-      track,
-      previousTrack,
-      encodings
-    }, {
-      F: __dxlog_file3,
-      L: 295,
-      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_file3,
-          L: 299,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        return previousTrack;
-      } else if (transceiver2) {
-        log2.verbose("replacing track", {
-          track,
-          previousTrack,
-          transceiver: transceiver2
-        }, {
-          F: __dxlog_file3,
-          L: 302,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        transceiver2.sender.replaceTrack(track).catch((err) => log2.catch(err, void 0, {
-          F: __dxlog_file3,
-          L: 303,
-          S: this,
-          C: (f, a) => f(...a)
-        }));
-        return previousTrack;
-      }
-    }
-    invariant3(track, void 0, {
-      F: __dxlog_file3,
-      L: 307,
-      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_file3,
-      L: 312,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const pushedTrackData = await this._pushTrackInBulk({
-      ctx,
-      peerConnection: this.session.peerConnection,
-      transceiver,
-      sessionId: this.session.sessionId,
-      trackName: stableId
-    });
-    invariant3(pushedTrackData, void 0, {
-      F: __dxlog_file3,
-      L: 321,
-      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_file3,
-      L: 328,
-      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_file3,
-      L: 346,
-      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);
-      }
-      invariant3(newTrackResponse.tracks, void 0, {
-        F: __dxlog_file3,
-        L: 359,
-        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_file3,
-          L: 411,
-          S: this,
-          C: (f, a) => f(...a)
-        }));
-      } else {
-        log2.info("missing track info", {
-          trackData,
-          availableTracks: Array.from(trackMap.keys())
-        }, {
-          F: __dxlog_file3,
-          L: 413,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    });
-    const onDispose = async () => {
-      if (mid) {
-        log2("closing pulled track ", trackData.trackName, {
-          F: __dxlog_file3,
-          L: 419,
-          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();
-    invariant3(this.session, void 0, {
-      F: __dxlog_file3,
-      L: 440,
-      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_file4 = "/__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_file4,
-    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/util/stub-media-streams.ts
-import { scheduleTaskInterval as scheduleTaskInterval2, waitForCondition } from "@dxos/async";
-import { cancelWithContext } from "@dxos/context";
-import { invariant as invariant4 } from "@dxos/invariant";
-var __dxlog_file5 = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/calls/util/stub-media-streams.ts";
-var createBlackCanvasStreamTrack = async ({ ctx, width, height }) => {
-  const canvas = document.createElement("canvas");
-  canvas.width = width;
-  canvas.height = height;
-  const canvasCtx = canvas.getContext("2d");
-  invariant4(canvasCtx, void 0, {
-    F: __dxlog_file5,
-    L: 28,
-    S: void 0,
-    A: [
-      "canvasCtx",
-      ""
-    ]
-  });
-  const drawFrame = () => {
-    canvasCtx.fillStyle = "black";
-    canvasCtx.fillRect(0, 0, canvas.width, canvas.height);
-  };
-  scheduleTaskInterval2(ctx, async () => drawFrame(), 200);
-  const track = canvas.captureStream().getVideoTracks()[0];
-  drawFrame();
-  await cancelWithContext(ctx, waitForCondition({
-    condition: () => track.readyState === "live",
-    timeout: 1e3
-  }));
-  return track;
-};
-var audioContextStartedPreviously = false;
-var userGestureEvents = [
-  "click",
-  "contextmenu",
-  "auxclick",
-  "dblclick",
-  "mousedown",
-  "mouseup",
-  "pointerup",
-  "touchend",
-  "keydown",
-  "keyup"
-];
-var createInaudibleAudioStreamTrack = async ({ ctx }) => {
-  const audioContext = new window.AudioContext();
-  const oscillator = audioContext.createOscillator();
-  oscillator.type = "triangle";
-  oscillator.frequency.setValueAtTime(20, audioContext.currentTime);
-  const gainNode = audioContext.createGain();
-  gainNode.gain.setValueAtTime(0, audioContext.currentTime);
-  oscillator.connect(gainNode);
-  const destination = audioContext.createMediaStreamDestination();
-  gainNode.connect(destination);
-  let oscillatorStarted = false;
-  const ensureOscillatorStarted = () => {
-    if (oscillatorStarted) return;
-    oscillator.start();
-    oscillatorStarted = true;
-  };
-  const stateChangeHandler = () => {
-    if (audioContext.state === "running") {
-      audioContextStartedPreviously = true;
-      ensureOscillatorStarted();
-    }
-    if (audioContext.state === "suspended" || audioContext.state === "interrupted") {
-      resumeAudioContext();
-    }
-  };
-  audioContext.addEventListener("statechange", stateChangeHandler);
-  const resumeAudioContext = () => {
-    void audioContext.resume().then(() => {
-      cleanUpUserGestureListeners();
-    });
-  };
-  const cleanUpUserGestureListeners = () => {
-    userGestureEvents.forEach((gesture) => {
-      document.removeEventListener(gesture, resumeAudioContext, {
-        capture: true
-      });
-    });
-  };
-  if (audioContextStartedPreviously) {
-    resumeAudioContext();
-  } else {
-    userGestureEvents.forEach((gesture) => {
-      document.addEventListener(gesture, resumeAudioContext, {
-        capture: true
-      });
-    });
-  }
-  ctx.onDispose(async () => {
-    cleanUpUserGestureListeners();
-    oscillator.disconnect();
-    oscillator.stop();
-    await audioContext.close();
-  });
-  return destination.stream.getAudioTracks()[0];
-};
-
-// src/calls/speaking-monitor.ts
-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 {
-  _mediaStreamTrack;
-  /**
-  * Event that is emitted when the user starts or stops speaking.
-  * It is debounced to prevent rapid state changes.
-  */
-  speakingChanged = new Event2();
-  /**
-  * Real state of the user speaking.
-  */
-  _isSpeaking = false;
-  _lastEventTime = 0;
-  _deferredUpdate;
-  constructor(_mediaStreamTrack) {
-    super(), this._mediaStreamTrack = _mediaStreamTrack;
-  }
-  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
-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_file6 = "/__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 = 100;
-var USE_INAUDIBLE_AUDIO = true;
-var MediaManager = class extends Resource4 {
-  stateUpdated = new Event3();
-  _state = {
-    pulledVideoStreams: {},
-    pulledAudioTracks: {}
-  };
-  _speakingMonitor = void 0;
-  _trackToReconcile = [];
-  _blackCanvasStreamTrack = void 0;
-  _inaudibleAudioStreamTrack = void 0;
-  _pushTracksTask = void 0;
-  _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_file6,
-      L: 229,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await cancelWithContext2(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_file6,
-      L: 247,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const pullResults = 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_file6,
-      L: 262,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this.stateUpdated.emit(this._state);
-    if (pullResults.some(({ shouldRetry }) => shouldRetry)) {
-      await cancelWithContext2(this._ctx, sleep2(RETRY_INTERVAL));
-      log4.info("retrying pull tracks", {
-        tracksToPull
-      }, {
-        F: __dxlog_file6,
-        L: 270,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      invariant5(this._pullTracksTask, void 0, {
-        F: __dxlog_file6,
-        L: 271,
-        S: this,
-        A: [
-          "this._pullTracksTask",
-          ""
-        ]
-      });
-      this._pullTracksTask.schedule();
-    }
-  }
-  async _pushTracks() {
-    if (!this._state.peer?.isOpen) {
-      return;
-    }
-    let updated = false;
-    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._maybePushTrack(this._state.audioTrack, this._state.pushedAudioTrack, [
-        {
-          networkPriority: "high"
-        }
-      ]),
-      this._maybePushTrack(this._state.screenshareTrack, this._state.pushedScreenshareTrack)
-    ]);
-    if (pushVideoResult.track !== this._state.pushedVideoTrack) {
-      this._state.pushedVideoTrack = pushVideoResult.track;
-      updated = true;
-    }
-    if (pushAudioResult.track !== this._state.pushedAudioTrack) {
-      this._state.pushedAudioTrack = pushAudioResult.track;
-      updated = true;
-    }
-    if (pushScreenshareResult.track !== this._state.pushedScreenshareTrack) {
-      this._state.pushedScreenshareTrack = pushScreenshareResult.track;
-      updated = true;
-    }
-    const shouldRetry = pushVideoResult.shouldRetry || pushAudioResult.shouldRetry || pushScreenshareResult.shouldRetry;
-    if (updated) {
-      this.stateUpdated.emit(this._state);
-    }
-    if (shouldRetry) {
-      await cancelWithContext2(this._ctx, sleep2(RETRY_INTERVAL));
-      log4.info("retrying push tracks", {
-        pushVideoResult,
-        pushAudioResult,
-        pushScreenshareResult
-      }, {
-        F: __dxlog_file6,
-        L: 310,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      invariant5(this._pushTracksTask, void 0, {
-        F: __dxlog_file6,
-        L: 311,
-        S: this,
-        A: [
-          "this._pushTracksTask",
-          ""
-        ]
-      });
-      this._pushTracksTask.schedule();
-    }
-  }
-  async _pullTrack(name) {
-    const ctx = this._ctx.derive();
-    try {
-      const trackData = TrackNameCodec.decode(name);
-      const track = await this._state.peer.pullTrack({
-        trackData: {
-          ...trackData,
-          mid: void 0
-        },
-        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]);
-          return {
-            shouldRetry: false
-          };
-        }
-        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];
-          });
-          return {
-            shouldRetry: false
-          };
-        }
-        default:
-          throw new Error(`Invalid track kind: ${track?.kind}`);
-      }
-    } catch (err) {
-      log4.info("failed to pull track", {
-        err,
-        name
-      }, {
-        F: __dxlog_file6,
-        L: 347,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      void ctx.dispose();
-      return {
-        shouldRetry: true
-      };
-    }
-  }
-  async _maybePushTrack(track, previousTrack, encodings) {
-    if (!track && !previousTrack) {
-      return {
-        track: void 0
-      };
-    }
-    const ctx = this._ctx.derive();
-    try {
-      return {
-        track: await this._state.peer.pushTrack({
-          ctx,
-          track: track ?? null,
-          previousTrack,
-          encodings
-        })
-      };
-    } catch (err) {
-      log4.info("failed to push track", {
-        err,
-        track,
-        previousTrack,
-        encodings
-      }, {
-        F: __dxlog_file6,
-        L: 373,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      void ctx.dispose();
-      return {
-        shouldRetry: true
-      };
-    }
-  }
-};
-_ts_decorate2([
-  synchronized2
-], MediaManager.prototype, "join", null);
-_ts_decorate2([
-  synchronized2
-], MediaManager.prototype, "leave", null);
-
-// src/calls/call-manager.ts
-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_file7 = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/calls/call-manager.ts";
-var CallManager = class extends Resource5 {
-  _client;
-  _registry;
-  callStateUpdated = new Event4();
-  // TODO(wittjosiah): Consolidate isSpeaking into the MediaState type.
-  mediaStateUpdated = new Event4();
-  left = new Event4();
-  /**
-  * Atom-based state. Updated via `_updateState()`.
-  * CAUTION: Do not change directly.
-  */
-  _stateAtom = Atom.make({
-    call: {},
-    media: {
-      pulledAudioTracks: {},
-      pulledVideoStreams: {}
-    }
-  });
-  // Derived atoms for reactive subscriptions.
-  _roomIdAtom = Atom.make((get) => get(this._stateAtom).call.roomId);
-  _raisedHandAtom = Atom.make((get) => get(this._stateAtom).call.raisedHand ?? false);
-  _speakingAtom = Atom.make((get) => get(this._stateAtom).call.speaking ?? false);
-  _joinedAtom = Atom.make((get) => get(this._stateAtom).call.joined ?? false);
-  _selfAtom = Atom.make((get) => get(this._stateAtom).call.self ?? {});
-  _tracksAtom = Atom.make((get) => get(this._stateAtom).call.tracks ?? {});
-  _usersAtom = Atom.make((get) => get(this._stateAtom).call.users ?? []);
-  _mediaAtom = Atom.make((get) => get(this._stateAtom).media);
-  _audioTracksToPlayAtom = Atom.make((get) => {
-    const state = get(this._stateAtom);
-    return (state.call.users ?? []).map((user) => user.tracks?.audioEnabled ? user.tracks?.audio : void 0).filter(isNonNullable2).map((track) => state.media.pulledAudioTracks[track]?.track).filter(isNonNullable2);
-  });
-  _videoStreamAtomFamily = Atom.family((name) => Atom.make((get) => get(this._stateAtom).media.pulledVideoStreams[name]?.stream));
-  _activityAtomFamily = Atom.family((key) => Atom.make((get) => get(this._stateAtom).call.activities?.[key]));
-  _swarmSynchronizer;
-  _mediaManager;
-  //
-  // Derived atoms for reactive UI subscriptions.
-  //
-  /** Derived atom for roomId. */
-  get roomIdAtom() {
-    return this._roomIdAtom;
-  }
-  /** Derived atom for raisedHand. */
-  get raisedHandAtom() {
-    return this._raisedHandAtom;
-  }
-  /** Derived atom for speaking. */
-  get speakingAtom() {
-    return this._speakingAtom;
-  }
-  /** Derived atom for joined. */
-  get joinedAtom() {
-    return this._joinedAtom;
-  }
-  /** Derived atom for self. */
-  get selfAtom() {
-    return this._selfAtom;
-  }
-  /** Derived atom for tracks. */
-  get tracksAtom() {
-    return this._tracksAtom;
-  }
-  /** Derived atom for users. */
-  get usersAtom() {
-    return this._usersAtom;
-  }
-  /** Derived atom for media. */
-  get mediaAtom() {
-    return this._mediaAtom;
-  }
-  /** Derived atom for audioTracksToPlay. */
-  get audioTracksToPlayAtom() {
-    return this._audioTracksToPlayAtom;
-  }
-  /** Returns the full state atom for reactive subscriptions. */
-  get stateAtom() {
-    return this._stateAtom;
-  }
-  /** Returns a derived atom for a video stream by name. */
-  videoStreamAtom(name) {
-    return this._videoStreamAtomFamily(name);
-  }
-  /** Returns a derived atom for an activity by key. */
-  activityAtom(key) {
-    return this._activityAtomFamily(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, _registry) {
-    super(), this._client = _client, this._registry = _registry;
-    this._client.config.getOrThrow("runtime.services.edge.url");
-    const networkService = this._client.services.services.NetworkService;
-    invariant6(networkService, "network service not found", {
-      F: __dxlog_file7,
-      L: 180,
-      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();
-    const roomId = this._registry.get(this._roomIdAtom);
-    roomId && this.left.emit(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._registry.set(this._stateAtom, {
-      call: this._swarmSynchronizer._getState(),
-      media: this._mediaManager._getState()
-    });
-  }
-};
-_ts_decorate3([
-  synchronized3
-], CallManager.prototype, "join", null);
-_ts_decorate3([
-  synchronized3
-], CallManager.prototype, "leave", null);
-
-// src/hooks/analytics.ts
-import { useCallback } from "react";
-import { useOperationInvoker } from "@dxos/app-framework/ui";
-import { Obj } from "@dxos/echo";
-import { ObservabilityOperation } from "@dxos/plugin-observability/operations";
-import { useOnTransition } from "@dxos/react-ui";
-var useOnEditAnalytics = (message, textBlock, editing) => {
-  const { invokePromise } = useOperationInvoker();
-  const onEdit = useCallback(() => {
-    if (!message || !textBlock) {
-      return;
-    }
-    const db = Obj.getDatabase(message);
-    if (!db) {
-      return;
-    }
-    void invokePromise(ObservabilityOperation.SendEvent, {
-      name: "threads.message.update",
-      properties: {
-        spaceId: db.spaceId,
-        messageId: message.id,
-        messageLength: textBlock?.text.length
-      }
-    });
-  }, [
-    invokePromise,
-    message,
-    textBlock
-  ]);
-  useOnTransition(editing, true, false, onEdit);
-};
-
-// src/hooks/useBlackCanvasStreamTrack.tsx
-import { useEffect, useState } from "react";
-import { scheduleTask as scheduleTask2 } from "@dxos/async";
-import { Context as Context2 } from "@dxos/context";
-var __dxlog_file8 = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/hooks/useBlackCanvasStreamTrack.tsx";
-var useBlackCanvasStreamTrack = () => {
-  const [blackCanvasStreamTrack, setBlackCanvasStreamTrack] = useState(void 0);
-  useEffect(() => {
-    const ctx = new Context2(void 0, {
-      F: __dxlog_file8,
-      L: 15
-    });
-    scheduleTask2(ctx, async () => {
-      const blackCanvasStreamTrack2 = await createBlackCanvasStreamTrack({
-        ctx,
-        width: 720,
-        height: 480
-      });
-      setBlackCanvasStreamTrack(blackCanvasStreamTrack2);
-    });
-    return () => {
-      void ctx.dispose();
-    };
-  }, []);
-  return blackCanvasStreamTrack;
-};
-
-// src/hooks/useDebugMode.ts
-import { useEffect as useEffect2, useState as useState2 } from "react";
-var useDebugMode = () => {
-  const [enabled, setEnabled] = useState2(false);
-  useEffect2(() => {
-    const handler = (ev) => {
-      if (ev.key.toLowerCase() === "d" && ev.ctrlKey) {
-        ev.preventDefault();
-        setEnabled(!enabled);
-      }
-    };
-    document.addEventListener("keypress", handler);
-    return () => {
-      document.removeEventListener("keypress", handler);
-    };
-  }, [
-    enabled
-  ]);
-  return enabled;
-};
-
-// src/hooks/useInaudibleAudioStreamTrack.tsx
-import { useEffect as useEffect3, useState as useState3 } from "react";
-import { scheduleTask as scheduleTask3 } from "@dxos/async";
-import { Context as Context3 } from "@dxos/context";
-var __dxlog_file9 = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/hooks/useInaudibleAudioStreamTrack.tsx";
-var useInaudibleAudioStreamTrack = () => {
-  const [audioStreamTrack, setAudioStreamTrack] = useState3(void 0);
-  useEffect3(() => {
-    const ctx = new Context3(void 0, {
-      F: __dxlog_file9,
-      L: 15
-    });
-    scheduleTask3(ctx, async () => {
-      const audioStreamTrack2 = await createInaudibleAudioStreamTrack({
-        ctx
-      });
-      setAudioStreamTrack(audioStreamTrack2);
-    });
-    return () => {
-      void ctx.dispose();
-    };
-  }, []);
-  return audioStreamTrack;
-};
-
-// src/hooks/useStatus.ts
-import { useEffect as useEffect4, useState as useState4 } from "react";
-var useStatus = (space, channel) => {
-  const [processing, setProcessing] = useState4(false);
-  useEffect4(() => {
-    if (!space || !channel) {
-      return;
-    }
-    const unsubscribe = space.listen(`status/${channel}`, (status) => {
-      const { event } = status.payload ?? {};
-      setProcessing(event === "processing");
-    });
-    const t = setInterval(() => {
-      setProcessing((prev) => {
-        if (typeof prev?.ts === "number" && Date.now() - prev.ts > 3e4) {
-          return void 0;
-        } else {
-          return prev;
-        }
-      });
-    }, 1e3);
-    return () => {
-      unsubscribe();
-      clearInterval(t);
-    };
-  }, [
-    space,
-    channel
-  ]);
-  return processing;
-};
-
-// src/hooks/useVideoStreamTrack.tsx
-import { useEffect as useEffect5, useRef, useState as useState5 } from "react";
-var useVideoStreamTrack = (videoElement, videoSrc) => {
-  const [videoStreamTrack, setVideoStreamTrack] = useState5(void 0);
-  const hadRun = useRef(false);
-  useEffect5(() => {
-    if (!videoElement.current || hadRun.current || !videoSrc) {
-      return;
-    }
-    hadRun.current = true;
-    videoElement.current.addEventListener("playing", () => {
-      if (videoStreamTrack) {
-        return;
-      }
-      const stream = videoElement.current.captureStream();
-      const track = stream.getTracks()[0];
-      if (track && !videoStreamTrack) {
-        setVideoStreamTrack(track);
-      }
-      stream.onaddtrack = (event) => {
-        if (event.track.kind === "video" && !videoStreamTrack) {
-          setVideoStreamTrack(event.track);
-        }
-      };
-    });
-    videoElement.current.src = videoSrc;
-  }, [
-    videoElement.current,
-    videoSrc
-  ]);
-  return videoStreamTrack;
-};
-
-// src/meta.ts
-import { trim } from "@dxos/util";
-var meta = {
-  id: "org.dxos.plugin.thread",
-  name: "Chat",
-  description: trim`
-    Multi-modal communication platform supporting text chat, voice, and video conferencing.
-    Create threaded conversations and add contextual comments directly on any workspace object.
-  `,
-  icon: "ph--video-conference--regular",
-  iconHue: "rose",
-  source: "https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-thread"
-};
-var THREAD_ITEM = `${meta.id}.item`;
-
-// src/ThreadPlugin.tsx
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import { Capability, Plugin } from "@dxos/app-framework";
-import { AppActivationEvents, AppPlugin } from "@dxos/app-toolkit";
-import { Annotation, Ref, Type as Type2 } from "@dxos/echo";
-import { Operation } from "@dxos/operation";
-import { ClientEvents } from "@dxos/plugin-client/types";
-import { MarkdownEvents } from "@dxos/plugin-markdown";
-import { SpaceOperation } from "@dxos/plugin-space/operations";
-import { SpaceCapabilities, SpaceEvents } from "@dxos/plugin-space/types";
-import { translations as threadTranslations } from "@dxos/react-ui-thread";
-import { AnchoredTo, Message, Thread } from "@dxos/types";
-import { AppGraphBuilder, BlueprintDefinition, CallManager as CallManager2, Markdown, OperationHandler, UndoMappings, ReactRoot, ReactSurface, ThreadState } from "#capabilities";
-import { THREAD_ITEM as THREAD_ITEM2, meta as meta3 } from "#meta";
-import { ThreadOperation } from "#operations";
-import { Channel as Channel2 } from "#types";
-
-// src/translations.ts
-import { Type } from "@dxos/echo";
-import { meta as meta2 } from "#meta";
-import { Channel } from "#types";
-var translations = [
-  {
-    "en-US": {
-      [Type.getTypename(Channel.Channel)]: {
-        "typename.label": "Channel",
-        "typename.label_zero": "Channels",
-        "typename.label_one": "Channel",
-        "typename.label_other": "Channels",
-        "object-name.placeholder": "New channel",
-        "add-object.label": "Add channel",
-        "rename-object.label": "Rename channel",
-        "delete-object.label": "Delete channel",
-        "object-deleted.label": "Channel deleted"
-      },
-      [meta2.id]: {
-        "plugin.name": "Chat",
-        "channel-title.label": "Title",
-        "message.placeholder": "Reply\u2026",
-        "activity.message": "Processing\u2026",
-        "anonymous.label": "Anonymous",
-        "delete-message-block.label": "Delete message block",
-        "detached-thread.label": "Referenced content was removed",
-        "delete-thread.label": "Delete thread",
-        "resolve-thread.label": "Resolve thread",
-        "thread-deleted.label": "Thread deleted",
-        "message-deleted.label": "Message deleted",
-        "comments.heading": "Comments",
-        "chat.heading": "Chat",
-        "draft.button": "DRAFT",
-        "no-comments.title": "Comments",
-        "no-comments.message": "Click on the <commentIcon></commentIcon> button in the document toolbar to create a comment thread on the selected text.",
-        "toggle-show-resolved.label": "Show resolved",
-        "unnamed-object-threads.label": "Threads",
-        "mark-as-resolved.label": "Mark as resolved",
-        "mark-as-unresolved.label": "Mark as unresolved",
-        "save-message.label": "Save",
-        "edit-message.label": "Edit",
-        "delete-message.label": "Delete message",
-        "accept-proposal.label": "Accept proposal",
-        "open-comments-panel.label": "Show Comments",
-        "comments.label": "Comments",
-        "show-all.label": "All comments",
-        "show-unresolved.label": "Unresolved comments",
-        "add-comment.label": "Add comment",
-        "channel-companion.label": "Channel",
-        "call-panel.label": "Active Call",
-        "display-name.label": "Display name",
-        "display-name.description": "Set your display name before joining a meeting.",
-        "display-name-input.placeholder": "Enter your name",
-        "set-display-name.label": "Continue",
-        "call-tab.label": "Call",
-        "meeting-status.title": "Calls",
-        "share-meeting-link.label": "Share meeting",
-        "show-webrtc-stats.title": "WebRTC Stats",
-        "show-calls-history.title": "Service History",
-        "meeting-summary.label": "Summary",
-        "summarize.label": "Summarize",
-        "summarizing.label": "Creating summary...",
-        "create-summary.message": "A summary doesn\u2019t exist for this meeting yet. Create one now?",
-        "icon-pin.label": "Pin video",
-        "icon-unpin.label": "Unpin video",
-        "icon-wave.label": "Waving",
-        "icon-muted.label": "Muted",
-        "join-call.button": "Join",
-        "leave-call.button": "Leave",
-        "mic-on.button": "Unmute",
-        "mic-off.button": "Mute",
-        "camera-on.button": "Turn camera on",
-        "camera-off.button": "Turn camera off",
-        "camera-off.label": "Camera off",
-        "raise-hand.button": "Raise hand",
-        "lower-hand.button": "Lower hand",
-        "screenshare-on.button": "Share screen",
-        "screenshare-off.button": "Stop streaming",
-        "channel-toolbar.title": "Channel actions",
-        "start-video-call.menu": "Start video call"
-      }
-    }
-  }
-];
-
-// src/ThreadPlugin.tsx
-var ThreadPlugin = Plugin.define(meta3).pipe(
-  AppPlugin.addAppGraphModule({
-    activate: AppGraphBuilder
-  }),
-  AppPlugin.addBlueprintDefinitionModule({
-    activate: BlueprintDefinition
-  }),
-  AppPlugin.addMetadataModule({
-    metadata: [
-      {
-        id: Type2.getTypename(Channel2.Channel),
-        metadata: {
-          icon: Annotation.IconAnnotation.get(Channel2.Channel).pipe(Option.getOrThrow).icon,
-          iconHue: Annotation.IconAnnotation.get(Channel2.Channel).pipe(Option.getOrThrow).hue ?? "white",
-          createObject: (props, options) => Effect.gen(function* () {
-            const object = Channel2.make(props);
-            return yield* Operation.invoke(SpaceOperation.AddObject, {
-              object,
-              target: options.target,
-              hidden: true,
-              targetNodeId: options.targetNodeId
-            });
-          })
-        }
-      },
-      {
-        id: Type2.getTypename(Thread.Thread),
-        metadata: {
-          // TODO(wittjosiah): Move out of metadata.
-          loadReferences: async (thread) => await Ref.Array.loadAll(thread.messages ?? [])
-        }
-      },
-      {
-        id: THREAD_ITEM2,
-        metadata: {
-          parse: (item, type) => {
-            switch (type) {
-              case "node":
-                return {
-                  id: item.id,
-                  label: item.name,
-                  data: item
-                };
-              case "object":
-                return item;
-              case "view-object":
-                return {
-                  id: `${item.id}-view`,
-                  object: item
-                };
-            }
-          }
-        }
-      }
-    ]
-  }),
-  AppPlugin.addOperationHandlerModule({
-    activate: OperationHandler
-  }),
-  AppPlugin.addOperationHandlerModule({
-    id: "undo-mappings",
-    activate: UndoMappings
-  }),
-  AppPlugin.addReactRootModule({
-    activate: ReactRoot
-  }),
-  AppPlugin.addSchemaModule({
-    schema: [
-      AnchoredTo.AnchoredTo,
-      Channel2.Channel,
-      Message.Message,
-      Thread.Thread
-    ]
-  }),
-  AppPlugin.addSurfaceModule({
-    activate: ReactSurface
-  }),
-  AppPlugin.addTranslationsModule({
-    translations: [
-      ...translations,
-      ...threadTranslations
-    ]
-  }),
-  Plugin.addModule({
-    id: "call-manager",
-    activatesOn: ClientEvents.ClientReady,
-    activate: CallManager2
-  }),
-  // TODO(wittjosiah): Currently not used but leaving because there will likely be settings for threads again.
-  // Plugin.addModule({
-  //   id: 'settings',
-  //   activatesOn: Events.SetupSettings,
-  //   activate: ThreadSettings,
-  // }),
-  Plugin.addModule({
-    id: "state",
-    // TODO(wittjosiah): Does not integrate with settings store.
-    //   Should this be a different event?
-    //   Should settings store be renamed to be more generic?
-    activatesOn: AppActivationEvents.SetupSettings,
-    activate: ThreadState
-  }),
-  Plugin.addModule({
-    id: "on-space-created",
-    activatesOn: SpaceEvents.SpaceCreated,
-    activate: () => Effect.succeed(Capability.contributes(SpaceCapabilities.OnCreateSpace, (params) => Operation.invoke(ThreadOperation.OnCreateSpace, params)))
-  }),
-  Plugin.addModule({
-    id: "markdown",
-    activatesOn: MarkdownEvents.SetupExtensions,
-    activate: Markdown
-  }),
-  Plugin.make
-);
-export {
-  CALLS_URL,
-  CallManager,
-  CallSwarmSynchronizer,
-  CallsServicePeer,
-  MediaManager,
-  SpeakingMonitor,
-  THREAD_ITEM,
-  ThreadCapabilities,
-  ThreadPlugin,
-  TrackNameCodec,
-  codec,
-  createBlackCanvasStreamTrack,
-  createInaudibleAudioStreamTrack,
-  getDeviceList,
-  getScreenshare,
-  getUserMediaTrack,
-  meta,
-  monitorAudioLevel,
-  useBlackCanvasStreamTrack,
-  useDebugMode,
-  useInaudibleAudioStreamTrack,
-  useOnEditAnalytics,
-  useStatus,
-  useVideoStreamTrack
-};
-//# sourceMappingURL=index.mjs.map