@dxos/plugin-thread 0.8.4-main.ae835ea → 0.8.4-main.bc674ce

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

@@ -50,7 +50,7 @@ export type CallState = {
   tracks?: UserState['tracks'];
 };
 
-export type CallSwarmSynchronizerParams = { networkService: NetworkService };
+export type CallSwarmSynchronizerProps = { networkService: NetworkService };
 
 /**
  * Period for peer to reconnect to the call swarm gracefully if connection was lost abruptly.
@@ -76,7 +76,7 @@ export class CallSwarmSynchronizer extends Resource {
 
   private _sendStateTask?: DeferredTask = undefined;
 
-  constructor({ networkService }: CallSwarmSynchronizerParams) {
+  constructor({ networkService }: CallSwarmSynchronizerProps) {
     super();
     this._networkService = networkService;
   }

package/src/calls/media-manager.ts

@@ -51,7 +51,7 @@ const MAX_WEB_CAM_FRAMERATE = 24;
 const MAX_WEB_CAM_BITRATE = 120_0000;
 const RETRY_INTERVAL = 100;
 
-export type MediaManagerParams = {
+export type MediaManagerProps = {
   serviceConfig: CallsServiceConfig;
 };
 
@@ -59,9 +59,13 @@ const USE_INAUDIBLE_AUDIO = true;
 
 export class MediaManager extends Resource {
   public readonly stateUpdated = new Event<MediaState>();
-  private readonly _state: MediaState = { pulledVideoStreams: {}, pulledAudioTracks: {} };
-  private _speakingMonitor?: SpeakingMonitor = undefined;
 
+  private readonly _state: MediaState = {
+    pulledVideoStreams: {},
+    pulledAudioTracks: {},
+  };
+
+  private _speakingMonitor?: SpeakingMonitor = undefined;
   private _trackToReconcile: EncodedTrackName[] = [];
   private _blackCanvasStreamTrack?: MediaStreamTrack = undefined;
   private _inaudibleAudioStreamTrack?: MediaStreamTrack = undefined;
@@ -85,6 +89,7 @@ export class MediaManager extends Resource {
       width: VIDEO_WIDTH,
       height: VIDEO_HEIGHT,
     });
+
     this._state.videoTrack = this._blackCanvasStreamTrack;
     this._state.videoStream = new MediaStream();
     this._state.videoStream.addTrack(this._state.videoTrack);
@@ -137,6 +142,7 @@ export class MediaManager extends Resource {
     this._state.videoStream!.removeTrack(this._state.videoTrack!);
     this._state.videoTrack = await getUserMediaTrack('videoinput', { width: VIDEO_WIDTH, height: VIDEO_HEIGHT });
     this._state.videoStream!.addTrack(this._state.videoTrack);
+
     this._state.videoEnabled = true;
     this.stateUpdated.emit(this._state);
     this._pushTracksTask!.schedule();
@@ -226,7 +232,6 @@ export class MediaManager extends Resource {
     // Wait for cloudflare to process the track.
     await cancelWithContext(this._ctx, sleep(800));
     const trackNames = this._trackToReconcile;
-
     const tracksToPull = trackNames.filter(
       (name) => !this._state.pulledAudioTracks[name] && !this._state.pulledVideoStreams[name],
     );
@@ -258,8 +263,8 @@ export class MediaManager extends Resource {
       currentAudioTracks: Object.keys(this._state.pulledAudioTracks),
       currentVideoStreams: Object.keys(this._state.pulledVideoStreams),
     });
-    this.stateUpdated.emit(this._state);
 
+    this.stateUpdated.emit(this._state);
     if (pullResults.some(({ shouldRetry }) => shouldRetry)) {
       await cancelWithContext(this._ctx, sleep(RETRY_INTERVAL));
       log.info('retrying pull tracks', { tracksToPull });
@@ -296,7 +301,6 @@ export class MediaManager extends Resource {
     }
 
     const shouldRetry = pushVideoResult.shouldRetry || pushAudioResult.shouldRetry || pushScreenshareResult.shouldRetry;
-
     if (updated) {
       this.stateUpdated.emit(this._state);
     }
@@ -356,7 +360,6 @@ export class MediaManager extends Resource {
     }
 
     const ctx = this._ctx.derive();
-
     try {
       return {
         track: await this._state.peer!.pushTrack({

package/src/calls/util/calls-service.ts

@@ -27,7 +27,7 @@ export type Session = {
 
 export type CallsServiceConfig = {
   apiBase: string;
-  apiExtraParams?: string;
+  apiExtraProps?: string;
   iceServers?: RTCIceServer[];
 };
 

package/src/calls/util/stub-media-streams.ts

@@ -60,13 +60,12 @@ const userGestureEvents = [
  */
 export const createInaudibleAudioStreamTrack = async ({ ctx }: { ctx: Context }): Promise<MediaStreamTrack> => {
   const audioContext = new window.AudioContext();
+
   const oscillator = audioContext.createOscillator();
   oscillator.type = 'triangle';
-  // roughly sounds like a box fan
   oscillator.frequency.setValueAtTime(20, audioContext.currentTime);
 
   const gainNode = audioContext.createGain();
-  // even w/ gain at 0 some packets are sent
   gainNode.gain.setValueAtTime(0, audioContext.currentTime);
   oscillator.connect(gainNode);
 
@@ -85,6 +84,7 @@ export const createInaudibleAudioStreamTrack = async ({ ctx }: { ctx: Context })
       audioContextStartedPreviously = true;
       ensureOscillatorStarted();
     }
+
     if (audioContext.state === 'suspended' || (audioContext.state as string) === 'interrupted') {
       resumeAudioContext();
     }

package/src/calls/util/task-scheduling.ts

@@ -27,8 +27,8 @@ export class FIFOScheduler {
 }
 
 // TODO(mykola): Reconcile with @dxos/async task scheduling.
-export class BulkRequestDispatcher<RequestEntryParams, BulkResponse> {
-  #currentBatch: RequestEntryParams[];
+export class BulkRequestDispatcher<RequestEntryProps, BulkResponse> {
+  #currentBatch: RequestEntryProps[];
   #currentBulkResponse: Promise<BulkResponse> | null;
   #batchSizeLimit: number;
 
@@ -43,8 +43,8 @@ export class BulkRequestDispatcher<RequestEntryParams, BulkResponse> {
    * At the event loop iteration end, the accumulated entries will be dispatched as a bulk request.
    */
   doBulkRequest(
-    params: RequestEntryParams,
-    bulkRequestFunc: (bulkCopy: RequestEntryParams[]) => Promise<BulkResponse>,
+    params: RequestEntryProps,
+    bulkRequestFunc: (bulkCopy: RequestEntryProps[]) => Promise<BulkResponse>,
   ): Promise<BulkResponse> {
     if (this.#currentBatch.length >= this.#batchSizeLimit) {
       // If it reaches the batch size limit, we make another bulk request.

package/src/capabilities/app-graph-builder/app-graph-builder.ts

@@ -0,0 +1,201 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capability, Common } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { AttentionCapabilities } from '@dxos/plugin-attention';
+import { ATTENDABLE_PATH_SEPARATOR, DECK_COMPANION_TYPE, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
+import { GraphBuilder, NodeMatcher } from '@dxos/plugin-graph';
+import { type SelectionManager, type SelectionMode, defaultSelection } from '@dxos/react-ui-attention';
+
+import { meta } from '../../meta';
+import { Channel, ThreadCapabilities, ThreadOperation, type ThreadState } from '../../types';
+import { getAnchor } from '../../util';
+
+type CommentDisabledParams = {
+  stateAtom: Atom.Atom<Atom.Writable<ThreadState>[]>;
+  selectionManager: SelectionManager;
+  objectId: string;
+  commentsType: string;
+  selectionMode: SelectionMode | undefined;
+};
+
+/**
+ * Atom family to derive whether the comment button should be disabled.
+ * Uses a composite key to ensure proper caching.
+ */
+const commentDisabledFamily = Atom.family(
+  ({ stateAtom, selectionManager, objectId, commentsType, selectionMode }: CommentDisabledParams) =>
+    Atom.make((get) => {
+      const stateAtoms = get(stateAtom);
+      const state = stateAtoms[0] ? get(stateAtoms[0]) : undefined;
+      const toolbar = state?.toolbar ?? {};
+      const selectionState = get(selectionManager.state);
+      const selection =
+        selectionState.selections[objectId] ?? (selectionMode ? defaultSelection(selectionMode) : undefined);
+      const anchor = getAnchor(selection);
+      const invalidSelection = !anchor;
+      const overlappingComment = toolbar[objectId];
+      return (commentsType === 'anchored' && invalidSelection) || overlappingComment;
+    }),
+);
+
+/** Match ECHO objects that are NOT Channels (i.e. objects that can have comments). */
+const whenCommentableObject = NodeMatcher.whenAll(
+  NodeMatcher.whenEchoObjectMatches,
+  NodeMatcher.whenNot(NodeMatcher.whenEchoTypeMatches(Channel.Channel)),
+);
+
+// TODO(wittjosiah): Highlight active calls in L1.
+//  Track active meetings by subscribing to meetings query and polling the swarms of recent meetings in the space.
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const capabilities = yield* Capability.Service;
+
+    const resolve = (typename: string) =>
+      capabilities.getAll(Common.Capability.Metadata).find(({ id }: { id: string }) => id === typename)?.metadata ?? {};
+
+    const extensions = yield* Effect.all([
+      GraphBuilder.createExtension({
+        id: `${meta.id}/active-call`,
+        match: NodeMatcher.whenRoot,
+        connector: (node, get) => {
+          const callManagerAtom = capabilities.atom(ThreadCapabilities.CallManager);
+          const [call] = get(callManagerAtom);
+          if (!call) {
+            return Effect.succeed([]);
+          }
+          // Use derived joinedAtom for efficient subscription.
+          const joined = get(call.joinedAtom);
+          return Effect.succeed(
+            joined
+              ? [
+                  {
+                    id: `${node.id}${ATTENDABLE_PATH_SEPARATOR}active-call`,
+                    type: DECK_COMPANION_TYPE,
+                    data: null,
+                    properties: {
+                      label: ['call panel label', { ns: meta.id }],
+                      icon: 'ph--video-conference--regular',
+                      position: 'hoist',
+                      disposition: 'hidden',
+                    },
+                  },
+                ]
+              : [],
+          );
+        },
+      }),
+      GraphBuilder.createTypeExtension({
+        id: `${meta.id}/channel-chat-companion`,
+        type: Channel.Channel,
+        connector: (channel, get) => {
+          const callManager = capabilities.get(ThreadCapabilities.CallManager);
+          // Use derived atoms for efficient subscription.
+          const joined = get(callManager.joinedAtom);
+          const roomId = get(callManager.roomIdAtom);
+          const isActive = joined && roomId === Obj.getDXN(channel).toString();
+          if (!isActive) {
+            return Effect.succeed([]);
+          }
+
+          return Effect.succeed([
+            {
+              id: `${Obj.getDXN(channel).toString()}${ATTENDABLE_PATH_SEPARATOR}chat`,
+              type: PLANK_COMPANION_TYPE,
+              data: 'chat',
+              properties: {
+                label: ['channel companion label', { ns: meta.id }],
+                icon: 'ph--hash--regular',
+                position: 'hoist',
+                disposition: 'hidden',
+              },
+            },
+          ]);
+        },
+      }),
+      GraphBuilder.createExtension({
+        id: `${meta.id}/comments-companion`,
+        match: (node) => {
+          if (!Obj.isObject(node.data) || Option.isNone(whenCommentableObject(node))) {
+            return Option.none();
+          }
+          const metadata = resolve(Obj.getTypename(node.data)!);
+          return typeof metadata.comments === 'string' ? Option.some(node) : Option.none();
+        },
+        connector: (node) =>
+          Effect.succeed([
+            {
+              id: [node.id, 'comments'].join(ATTENDABLE_PATH_SEPARATOR),
+              type: PLANK_COMPANION_TYPE,
+              data: 'comments',
+              properties: {
+                label: ['comments label', { ns: meta.id }],
+                icon: 'ph--chat-text--regular',
+                disposition: 'hidden',
+                position: 'hoist',
+              },
+            },
+          ]),
+      }),
+      GraphBuilder.createExtension({
+        id: `${meta.id}/comment-toolbar`,
+        match: (node) => {
+          if (!Obj.isObject(node.data) || Option.isNone(whenCommentableObject(node))) {
+            return Option.none();
+          }
+          const metadata = resolve(Obj.getTypename(node.data)!);
+          return typeof metadata.comments === 'string' ? Option.some(node.data) : Option.none();
+        },
+        actions: (object, get) => {
+          const stateAtom = capabilities.atom(ThreadCapabilities.State);
+          const selectionManager = capabilities.get(AttentionCapabilities.Selection);
+          const objectId = Obj.getDXN(object).toString();
+          const metadata = resolve(Obj.getTypename(object)!);
+
+          const disabled = get(
+            commentDisabledFamily({
+              stateAtom,
+              selectionManager,
+              objectId,
+              commentsType: metadata.comments as string,
+              selectionMode: metadata.selectionMode,
+            }),
+          );
+
+          return Effect.succeed([
+            {
+              id: `${Obj.getDXN(object).toString()}/comment`,
+              data: Effect.fnUntraced(function* () {
+                const metadata = resolve(Obj.getTypename(object)!);
+                const selection = selectionManager.getSelection(Obj.getDXN(object).toString());
+                const anchor = metadata.comments === 'anchored' ? getAnchor(selection) : Date.now().toString();
+                const name = metadata.getAnchorLabel?.(object, anchor);
+                yield* Operation.invoke(ThreadOperation.Create, {
+                  anchor,
+                  name,
+                  subject: object,
+                });
+              }),
+              properties: {
+                label: ['add comment label', { ns: meta.id }],
+                icon: 'ph--chat-text--regular',
+                disposition: 'toolbar',
+                disabled,
+                testId: 'thread.comment.add',
+              },
+            },
+          ]);
+        },
+      }),
+    ]);
+
+    return Capability.contributes(Common.Capability.AppGraphBuilder, extensions);
+  }),
+);

package/src/capabilities/app-graph-builder/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));

package/src/capabilities/blueprint-definition/blueprint-definition.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability, Common } from '@dxos/app-framework';
+
+import { ThreadBlueprint } from '../../blueprints';
+
+export type BlueprintCapabilities = [
+  Capability.Capability<typeof Common.Capability.Functions>,
+  Capability.Capability<typeof Common.Capability.BlueprintDefinition>,
+];
+
+const blueprintDefinition = Capability.makeModule<[], BlueprintCapabilities>(() =>
+  Effect.succeed([
+    Capability.contributes(Common.Capability.Functions, ThreadBlueprint.functions),
+    Capability.contributes(Common.Capability.BlueprintDefinition, ThreadBlueprint.make()),
+  ]),
+);
+
+export default blueprintDefinition;

package/src/capabilities/blueprint-definition/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));

package/src/capabilities/call-manager/call-manager.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability, Common } from '@dxos/app-framework';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+import { CallManager } from '../../calls';
+import { ThreadCapabilities } from '../../types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const client = yield* Capability.get(ClientCapabilities.Client);
+    const registry = yield* Capability.get(Common.Capability.AtomRegistry);
+    const callManager = new CallManager(client, registry);
+    yield* Effect.tryPromise(() => callManager.open());
+
+    return Capability.contributes(ThreadCapabilities.CallManager, callManager, () =>
+      Effect.sync(() => {
+        void callManager.close();
+      }),
+    );
+  }),
+);

package/src/capabilities/call-manager/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const CallManager = Capability.lazy('CallManager', () => import('./call-manager'));

package/src/capabilities/index.ts

@@ -2,16 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
-
-export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
-export const CallManager = lazy(() => import('./call-manager'));
-export const IntentResolver = lazy(() => import('./intent-resolver'));
-export const Markdown = lazy(() => import('./markdown'));
-export const ReactRoot = lazy(() => import('./react-root'));
-export const ReactSurface = lazy(() => import('./react-surface'));
-export const ThreadSettings = lazy(() => import('./settings'));
-export const ThreadState = lazy(() => import('./state'));
-export const Toolkit = lazy(() => import('./toolkit'));
-
-export * from './capabilities';
+export * from './app-graph-builder';
+export * from './blueprint-definition';
+export * from './call-manager';
+export * from './markdown';
+export * from './operation-resolver';
+export * from './react-root';
+export * from './react-surface';
+export * from './repair';
+export * from './settings';
+export * from './state';

package/src/capabilities/markdown/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const Markdown = Capability.lazy('Markdown', () => import('./markdown'));

package/src/capabilities/markdown/markdown.ts

@@ -0,0 +1,83 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { EditorView } from '@codemirror/view';
+import * as Effect from 'effect/Effect';
+
+import { Capability, Common } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
+import { ATTENDABLE_PATH_SEPARATOR, DeckOperation } from '@dxos/plugin-deck/types';
+import { MarkdownCapabilities } from '@dxos/plugin-markdown';
+import { type EditorState, commentClickedEffect, commentsState, overlap } from '@dxos/ui-editor';
+
+import { threads } from '../../extensions';
+import { ThreadCapabilities } from '../../types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    // Get context for lazy capability access in callbacks.
+    const capabilities = yield* Capability.Service;
+
+    return Capability.contributes(MarkdownCapabilities.Extensions, [
+      ({ document: doc }) => {
+        const { invokePromise } = capabilities.get(Common.Capability.OperationInvoker);
+        const registry = capabilities.get(Common.Capability.AtomRegistry);
+        const stateAtom = capabilities.get(ThreadCapabilities.State);
+        return threads({ registry, stateAtom }, doc, invokePromise);
+      },
+      ({ document: doc }) => {
+        if (!doc) return [];
+        const registry = capabilities.get(Common.Capability.AtomRegistry);
+        const stateAtom = capabilities.get(ThreadCapabilities.State);
+
+        return EditorView.updateListener.of((update) => {
+          if (update.docChanged || update.selectionSet) {
+            const objectId = Obj.getDXN(doc).toString();
+            const overlaps = selectionOverlapsComment(update.state);
+            const current = registry.get(stateAtom);
+            registry.set(stateAtom, {
+              ...current,
+              toolbar: { ...current.toolbar, [objectId]: overlaps },
+            });
+          }
+        });
+      },
+      ({ document: doc }) => {
+        if (!doc) return [];
+        const { invokePromise } = capabilities.get(Common.Capability.OperationInvoker);
+        const id = Obj.getDXN(doc).toString();
+
+        return EditorView.updateListener.of((update) => {
+          update.transactions.forEach((transaction) => {
+            transaction.effects.forEach(async (effect) => {
+              if (effect.is(commentClickedEffect)) {
+                void invokePromise(DeckOperation.ChangeCompanion, {
+                  primary: id,
+                  companion: `${id}${ATTENDABLE_PATH_SEPARATOR}comments`,
+                });
+              }
+            });
+          });
+        });
+      },
+    ]);
+  }),
+);
+
+const selectionOverlapsComment = (state: EditorState): boolean => {
+  // May not be defined if thread plugin not installed.
+  const commentState = state.field(commentsState, false);
+  if (commentState === undefined) {
+    return false;
+  }
+
+  const { selection } = state;
+  for (const range of selection.ranges) {
+    if (commentState.comments.some(({ range: commentRange }) => overlap(commentRange, range))) {
+      return true;
+    }
+  }
+
+  return false;
+};

package/src/capabilities/operation-resolver/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const OperationResolver = Capability.lazy('OperationResolver', () => import('./operation-resolver'));