@dxos/plugin-thread 0.8.4-main.f5c0578 → 0.8.4-main.fcc0d83b33

package/dist/lib/node-esm/index.mjs

@@ -1,196 +1,1845 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  CALLS_URL,
-  CallManager,
-  CallSwarmSynchronizer,
-  CallsServicePeer,
-  MediaManager,
-  SpeakingMonitor,
-  TrackNameCodec,
-  codec,
-  getDeviceList,
-  getScreenshare,
-  getUserMediaTrack,
-  monitorAudioLevel
-} from "./chunk-4TME3BR4.mjs";
-import {
-  ChannelType,
-  ThreadAction,
-  ThreadType
-} from "./chunk-XVKWHTH4.mjs";
-import {
-  AppGraphBuilder,
-  CallManager as CallManager2,
-  IntentResolver,
-  Markdown,
-  ReactRoot,
-  ReactSurface,
-  ThreadState
-} from "./chunk-6CRHHOST.mjs";
 import {
   ThreadCapabilities
-} from "./chunk-PYTVBN5J.mjs";
-import {
-  useDebugMode,
-  useInaudibleAudioStreamTrack,
-  useOnEditAnalytics,
-  useStatus,
-  useVideoStreamTrack
-} from "./chunk-SED3O2XO.mjs";
-import {
-  createBlackCanvasStreamTrack,
-  createInaudibleAudioStreamTrack
-} from "./chunk-QBHKLWGR.mjs";
-import {
-  THREAD_ITEM,
-  THREAD_PLUGIN,
-  meta
-} from "./chunk-GRLRWTRU.mjs";
+} from "./chunk-2Q6V7NGK.mjs";
+import "./chunk-HSLMI22Q.mjs";
 
-// src/ThreadPlugin.tsx
-import { Capabilities, Events, contributes, createIntent, defineModule, definePlugin } from "@dxos/app-framework";
-import { Ref } from "@dxos/echo";
-import { ClientCapabilities, ClientEvents } from "@dxos/plugin-client";
-import { MarkdownEvents } from "@dxos/plugin-markdown";
-import { SpaceCapabilities, SpaceEvents } from "@dxos/plugin-space";
-import { defineObjectForm } from "@dxos/plugin-space/types";
-import { translations as threadTranslations } from "@dxos/react-ui-thread";
-import { AnchoredTo, DataType } from "@dxos/schema";
+// 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/translations.ts
-var translations = [
-  {
-    "en-US": {
-      [ChannelType.typename]: {
-        "typename label": "Channel",
-        "typename label_zero": "Channels",
-        "typename label_one": "Channel",
-        "typename label_other": "Channels",
-        "object name placeholder": "New channel",
-        "rename object label": "Rename channel",
-        "delete object label": "Delete channel"
-      },
-      [meta.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": "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",
-        "open comments panel label": "Show Comments",
-        "comments label": "Comments",
-        "show all label": "All comments",
-        "show unresolved label": "Unresolved comments",
-        "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": "Meeting",
-        "share meeting link label": "Share meeting",
-        "show webrtc stats title": "Detailed WebRTC Stats",
-        "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?",
-        "join call": "Join",
-        "leave call": "Leave",
-        "lobby participants_zero": "No participants",
-        "lobby participants_one": "1 participant",
-        "lobby participants_other": "{{count}} participants",
-        "icon pin": "Pin video",
-        "icon unpin": "Unpin video",
-        "icon wave": "Waving",
-        "icon muted": "Muted",
-        "icon speaking": "Speaking",
-        "mic on": "Unmute",
-        "mic off": "Mute",
-        "camera on": "Turn camera on",
-        "camera off": "Turn camera off",
-        "camera off label": "Camera off",
-        "raise hand": "Raise hand",
-        "lower hand": "Lower hand",
-        "screenshare on": "Share screen",
-        "screenshare off": "Stop streaming"
+// 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, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 20, S: void 0, A: ["trackData.sessionId", ""] });
+    invariant(trackData.trackName, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 21, S: void 0, A: ["trackData.trackName", ""] });
+    invariant(trackData.mid, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 22, 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
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-thread/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 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
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 102, S: this });
+      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, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 122, S: this, A: ["this._state.roomId", ""] });
+    invariant2(!this._swarmCtx, "Already joined", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 123, S: this, A: ["!this._swarmCtx", "'Already joined'"] });
+    this._swarmCtx = new Context(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 124 });
+    const topic = getTopic(this._state.roomId);
+    log("joining swarm", {
+      topic,
+      peer: {
+        identityKey: this._identityKey,
+        peerKey: this._deviceKey
+      }
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 126, S: this });
+    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
+          }
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 140, S: this });
+        void this._networkService.leaveSwarm({
+          topic,
+          peer: {
+            identityKey: this._identityKey,
+            peerKey: this._deviceKey
+          }
+        }).catch((err) => log.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 153, S: this }));
+      }
+      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, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 216, 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
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 227, S: this });
+        return void 0;
+      }
+    }).filter(isNonNullable);
+    this._state.users = users;
+    this._state.self = users.find((user) => user.id === this._deviceKey);
+    log("reconciling swarm state", {
+      users
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 236, S: this });
+    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
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 58, S: this });
+        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
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 68, S: this });
+        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, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 79, S: this });
+            return;
+          }
+          log2.info("calls iceConnectionState timed out", {
+            state: peerConnection.iceConnectionState,
+            timeoutSeconds
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 82, S: this });
+          void this._persistentLifecycle.scheduleRestart();
+        }, timeoutSeconds * 1e3);
+      }
+    });
+    return peerConnection;
+  }
+  async _initiateCallSession() {
+    log2("creating new session", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 93, S: this });
+    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()
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 113, S: this });
+      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
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 141, S: this });
+      throw error;
+    }
+  }
+  async _pushTrackInBulk({ ctx, peerConnection, transceiver, sessionId, trackName }) {
+    log2.verbose("pushing track ", trackName, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 150, S: this });
+    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, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 174, 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, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 195, S: this });
+      }
+    });
+    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, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 209, S: this, A: ["this.session", ""] });
+    log2("trying to push track", {
+      track,
+      previousTrack,
+      encodings
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 210, S: this });
+    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
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 218, S: this });
+        return previousTrack;
+      } else if (transceiver2) {
+        log2.verbose("replacing track", {
+          track,
+          previousTrack,
+          transceiver: transceiver2
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 225, S: this });
+        transceiver2.sender.replaceTrack(track).catch((err) => log2.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 230, S: this }));
+        return previousTrack;
+      }
+    }
+    invariant3(track, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 234, S: this, A: ["track", ""] });
+    const stableId = crypto.randomUUID();
+    const transceiver = this.session.peerConnection.addTransceiver(track, {
+      direction: "sendonly"
+    });
+    log2.verbose("creating transceiver", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 240, S: this });
+    const pushedTrackData = await this._pushTrackInBulk({
+      ctx,
+      peerConnection: this.session.peerConnection,
+      transceiver,
+      sessionId: this.session.sessionId,
+      trackName: stableId
+    });
+    invariant3(pushedTrackData, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 248, 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, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 257, S: this }));
+    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
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 263, S: this });
+    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, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 276, 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, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 315, S: this }));
+      } else {
+        log2.info("missing track info", {
+          trackData,
+          availableTracks: Array.from(trackMap.keys())
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 317, S: this });
+      }
+    });
+    const onDispose = async () => {
+      if (mid) {
+        log2("closing pulled track ", trackData.trackName, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 325, S: this });
+        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, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 336, 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, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 15, S: void 0 });
+  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, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 16, 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
+var __dxlog_file6 = "/__w/dxos/dxos/packages/plugins/plugin-thread/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 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, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 171, S: this });
+    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)
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 180, S: this });
+    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)
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 195, S: this });
+    this.stateUpdated.emit(this._state);
+    if (pullResults.some(({ shouldRetry }) => shouldRetry)) {
+      await cancelWithContext2(this._ctx, sleep2(RETRY_INTERVAL));
+      log4.info("retrying pull tracks", {
+        tracksToPull
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 202, S: this });
+      invariant5(this._pullTracksTask, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 205, 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
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 246, S: this });
+      invariant5(this._pushTracksTask, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 251, 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
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 303, S: this });
+      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
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 330, S: this });
+      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
+var __dxlog_file7 = "/__w/dxos/dxos/packages/plugins/plugin-thread/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 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", { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 128, 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, { "~LogMeta": "~LogMeta", F: __dxlog_file8, L: 11 });
+    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, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 11 });
+    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
-var ThreadPlugin = () => definePlugin(meta, [
-  defineModule({
-    id: `${meta.id}/module/call-manager`,
-    activatesOn: ClientEvents.ClientReady,
-    activate: CallManager2
-  }),
-  // TODO(wittjosiah): Currently not used but leaving because there will likely be settings for threads again.
-  // defineModule({
-  //   id: `${meta.id}/module/settings`,
-  //   activatesOn: Events.SetupSettings,
-  //   activate: ThreadSettings,
-  // }),
-  defineModule({
-    id: `${meta.id}/module/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: Events.SetupSettings,
-    activate: ThreadState
+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 { Operation } from "@dxos/compute";
+import { Annotation, Ref, Type } from "@dxos/echo";
+import { ClientEvents } from "@dxos/plugin-client/types";
+import { MarkdownEvents } from "@dxos/plugin-markdown/types";
+import { SpaceOperation } from "@dxos/plugin-space/operations";
+import { SpaceCapabilities, SpaceEvents } from "@dxos/plugin-space/types";
+import { translations as threadTranslations } from "@dxos/react-ui-thread/translations";
+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 meta2 } from "#meta";
+import { ThreadOperation } from "#operations";
+import { translations } from "#translations";
+import { Channel } from "#types";
+var ThreadPlugin = Plugin.define(meta2).pipe(
+  AppPlugin.addAppGraphModule({
+    activate: AppGraphBuilder
   }),
-  defineModule({
-    id: `${meta.id}/module/translations`,
-    activatesOn: Events.SetupTranslations,
-    activate: () => contributes(Capabilities.Translations, [
-      ...translations,
-      ...threadTranslations
-    ])
+  AppPlugin.addBlueprintDefinitionModule({
+    activate: BlueprintDefinition
   }),
-  defineModule({
-    id: `${meta.id}/module/metadata`,
-    activatesOn: Events.SetupMetadata,
-    activate: () => [
-      contributes(Capabilities.Metadata, {
-        id: ChannelType.typename,
+  AppPlugin.addMetadataModule({
+    metadata: [
+      {
+        id: Type.getTypename(Channel.Channel),
         metadata: {
-          icon: "ph--hash--regular"
+          icon: Annotation.IconAnnotation.get(Channel.Channel).pipe(Option.getOrThrow).icon,
+          iconHue: Annotation.IconAnnotation.get(Channel.Channel).pipe(Option.getOrThrow).hue ?? "white",
+          createObject: (props, options) => Effect.gen(function* () {
+            const object = Channel.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId
+            });
+          })
         }
-      }),
-      contributes(Capabilities.Metadata, {
-        id: ThreadType.typename,
+      },
+      {
+        id: Type.getTypename(Thread.Thread),
         metadata: {
           // TODO(wittjosiah): Move out of metadata.
           loadReferences: async (thread) => await Ref.Array.loadAll(thread.messages ?? [])
         }
-      }),
-      contributes(Capabilities.Metadata, {
-        id: DataType.Message.typename,
-        metadata: {
-          // TODO(wittjosiah): Move out of metadata.
-          loadReferences: (message) => []
-        }
-      }),
-      contributes(Capabilities.Metadata, {
-        id: THREAD_ITEM,
+      },
+      {
+        id: THREAD_ITEM2,
         metadata: {
           parse: (item, type) => {
             switch (type) {
@@ -210,70 +1859,67 @@ var ThreadPlugin = () => definePlugin(meta, [
             }
           }
         }
-      })
+      }
     ]
   }),
-  defineModule({
-    id: `${meta.id}/module/object-form`,
-    activatesOn: ClientEvents.SetupSchema,
-    activate: () => contributes(SpaceCapabilities.ObjectForm, defineObjectForm({
-      objectSchema: ChannelType,
-      getIntent: (_, options) => createIntent(ThreadAction.CreateChannel, {
-        spaceId: options.space.id
-      })
-    }))
+  AppPlugin.addOperationHandlerModule({
+    activate: OperationHandler
   }),
-  defineModule({
-    id: `${meta.id}/module/schema`,
-    activatesOn: ClientEvents.SetupSchema,
-    activate: () => contributes(ClientCapabilities.Schema, [
-      AnchoredTo,
-      ThreadType,
-      DataType.Message,
-      DataType.MessageV1
-    ])
+  AppPlugin.addOperationHandlerModule({
+    id: "undo-mappings",
+    activate: UndoMappings
   }),
-  defineModule({
-    id: `${meta.id}/module/migration`,
-    activatesOn: ClientEvents.SetupMigration,
-    activate: () => contributes(ClientCapabilities.Migration, [
-      DataType.MessageV1ToV2
-    ])
+  AppPlugin.addReactRootModule({
+    activate: ReactRoot
   }),
-  defineModule({
-    id: `${meta.id}/module/on-space-created`,
-    activatesOn: SpaceEvents.SpaceCreated,
-    activate: () => contributes(SpaceCapabilities.OnSpaceCreated, ({ space, rootCollection }) => createIntent(ThreadAction.OnSpaceCreated, {
-      space,
-      rootCollection
-    }))
+  AppPlugin.addSchemaModule({
+    schema: [
+      AnchoredTo.AnchoredTo,
+      Channel.Channel,
+      Message.Message,
+      Thread.Thread
+    ]
   }),
-  defineModule({
-    id: `${meta.id}/module/markdown`,
-    activatesOn: MarkdownEvents.SetupExtensions,
-    activate: Markdown
+  AppPlugin.addSurfaceModule({
+    activate: ReactSurface
   }),
-  defineModule({
-    id: `${meta.id}/module/react-root`,
-    activatesOn: Events.Startup,
-    activate: ReactRoot
+  AppPlugin.addTranslationsModule({
+    translations: [
+      ...translations,
+      ...threadTranslations
+    ]
   }),
-  defineModule({
-    id: `${meta.id}/module/react-surface`,
-    activatesOn: Events.SetupReactSurface,
-    activate: ReactSurface
+  Plugin.addModule({
+    id: "call-manager",
+    activatesOn: ClientEvents.ClientReady,
+    activate: CallManager2
   }),
-  defineModule({
-    id: `${meta.id}/module/intent-resolver`,
-    activatesOn: Events.SetupIntentResolver,
-    activate: IntentResolver
+  // 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
   }),
-  defineModule({
-    id: `${meta.id}/module/app-graph-builder`,
-    activatesOn: Events.SetupAppGraph,
-    activate: AppGraphBuilder
-  })
-]);
+  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,
@@ -282,7 +1928,6 @@ export {
   MediaManager,
   SpeakingMonitor,
   THREAD_ITEM,
-  THREAD_PLUGIN,
   ThreadCapabilities,
   ThreadPlugin,
   TrackNameCodec,
@@ -294,6 +1939,7 @@ export {
   getUserMediaTrack,
   meta,
   monitorAudioLevel,
+  useBlackCanvasStreamTrack,
   useDebugMode,
   useInaudibleAudioStreamTrack,
   useOnEditAnalytics,