@dxos/plugin-thread 0.8.4-main.1068cf700f → 0.8.4-main.1c7ec43d41

package/src/capabilities/{app-graph-builder/app-graph-builder.ts → app-graph-builder.ts}

@@ -7,17 +7,20 @@ import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 
 import { Capability } from '@dxos/app-framework';
-import { AppCapabilities } from '@dxos/app-toolkit';
+import { AppCapabilities, AppNode } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
 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 { AttentionCapabilities } from '@dxos/plugin-attention/types';
 import { GraphBuilder, NodeMatcher } from '@dxos/plugin-graph';
+import { linkedSegment } from '@dxos/react-ui-attention';
 import { type SelectionManager, type SelectionMode, defaultSelection } from '@dxos/react-ui-attention';
+import { Channel } from '@dxos/types';
 
-import { meta } from '../../meta';
-import { Channel, ThreadCapabilities, ThreadOperation, type ThreadState } from '../../types';
-import { getAnchor } from '../../util';
+import { meta } from '#meta';
+import { ThreadOperation } from '#operations';
+import { ThreadCapabilities, type ThreadState } from '#types';
+
+import { getAnchor } from '../util';
 
 type CommentDisabledParams = {
   stateAtom: Atom.Atom<Atom.Writable<ThreadState>[]>;
@@ -59,12 +62,12 @@ export default Capability.makeModule(
   Effect.fnUntraced(function* () {
     const capabilities = yield* Capability.Service;
 
-    const resolve = (typename: string) =>
-      capabilities.getAll(AppCapabilities.Metadata).find(({ id }: { id: string }) => id === typename)?.metadata ?? {};
+    const getCommentConfig = (typename: string) =>
+      capabilities.getAll(AppCapabilities.CommentConfig).find(({ id }) => id === typename);
 
     const extensions = yield* Effect.all([
       GraphBuilder.createExtension({
-        id: `${meta.id}/active-call`,
+        id: 'active-call',
         match: NodeMatcher.whenRoot,
         connector: (node, get) => {
           const callManagerAtom = capabilities.atom(ThreadCapabilities.CallManager);
@@ -77,24 +80,20 @@ export default Capability.makeModule(
           return Effect.succeed(
             joined
               ? [
-                  {
-                    id: `${node.id}${ATTENDABLE_PATH_SEPARATOR}active-call`,
-                    type: DECK_COMPANION_TYPE,
+                  AppNode.makeDeckCompanion({
+                    id: 'active-call',
+                    label: ['call-panel.label', { ns: meta.id }],
+                    icon: 'ph--video-conference--regular',
                     data: null,
-                    properties: {
-                      label: ['call panel label', { ns: meta.id }],
-                      icon: 'ph--video-conference--regular',
-                      position: 'hoist',
-                      disposition: 'hidden',
-                    },
-                  },
+                    position: 'hoist',
+                  }),
                 ]
               : [],
           );
         },
       }),
       GraphBuilder.createTypeExtension({
-        id: `${meta.id}/channel-chat-companion`,
+        id: 'channel-chat-companion',
         type: Channel.Channel,
         connector: (channel, get) => {
           const callManager = capabilities.get(ThreadCapabilities.CallManager);
@@ -107,77 +106,71 @@ export default Capability.makeModule(
           }
 
           return Effect.succeed([
-            {
-              id: `${Obj.getDXN(channel).toString()}${ATTENDABLE_PATH_SEPARATOR}chat`,
-              type: PLANK_COMPANION_TYPE,
+            AppNode.makeCompanion({
+              id: 'chat',
+              label: ['channel-companion.label', { ns: meta.id }],
+              icon: 'ph--hash--regular',
               data: 'chat',
-              properties: {
-                label: ['channel companion label', { ns: meta.id }],
-                icon: 'ph--hash--regular',
-                position: 'hoist',
-                disposition: 'hidden',
-              },
-            },
+              position: 'hoist',
+            }),
           ]);
         },
       }),
       GraphBuilder.createExtension({
-        id: `${meta.id}/comments-companion`,
+        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();
+          const commentConfig = getCommentConfig(Obj.getTypename(node.data)!);
+          return commentConfig ? Option.some(node) : Option.none();
         },
-        connector: (node) =>
+        connector: () =>
           Effect.succeed([
-            {
-              id: [node.id, 'comments'].join(ATTENDABLE_PATH_SEPARATOR),
-              type: PLANK_COMPANION_TYPE,
+            AppNode.makeCompanion({
+              id: linkedSegment('comments'),
+              label: ['comments.label', { ns: meta.id }],
+              icon: 'ph--chat-text--regular',
               data: 'comments',
-              properties: {
-                label: ['comments label', { ns: meta.id }],
-                icon: 'ph--chat-text--regular',
-                disposition: 'hidden',
-                position: 'hoist',
-              },
-            },
+              position: 'hoist',
+            }),
           ]),
       }),
       GraphBuilder.createExtension({
-        id: `${meta.id}/comment-toolbar`,
+        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();
+          const commentConfig = getCommentConfig(Obj.getTypename(node.data)!);
+          return commentConfig ? Option.some(node) : Option.none();
         },
-        actions: (object, get) => {
+        actions: (matched, get) => {
+          const object = matched.data;
+          const objectDxn = Obj.getDXN(object).toString();
           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 commentConfig = getCommentConfig(Obj.getTypename(object)!)!;
 
           const disabled = get(
             commentDisabledFamily({
               stateAtom,
               selectionManager,
-              objectId,
-              commentsType: metadata.comments as string,
-              selectionMode: metadata.selectionMode,
+              objectId: objectDxn,
+              commentsType: commentConfig.comments,
+              selectionMode: commentConfig.selectionMode as SelectionMode | undefined,
             }),
           );
 
           return Effect.succeed([
             {
-              id: `${Obj.getDXN(object).toString()}/comment`,
+              id: '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);
+                const config = getCommentConfig(Obj.getTypename(object)!)!;
+                const selection = selectionManager.getSelection(objectDxn);
+                const anchor =
+                  (config.comments === 'anchored' ? getAnchor(selection) : undefined) ?? Date.now().toString();
+                const name = config.getAnchorLabel?.(object, anchor);
                 yield* Operation.invoke(ThreadOperation.Create, {
                   anchor,
                   name,
@@ -185,7 +178,7 @@ export default Capability.makeModule(
                 });
               }),
               properties: {
-                label: ['add comment label', { ns: meta.id }],
+                label: ['add-comment.label', { ns: meta.id }],
                 icon: 'ph--chat-text--regular',
                 disposition: 'toolbar',
                 disabled,

package/src/capabilities/blueprint-definition.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint } from '@dxos/compute';
+
+import { ThreadBlueprint } from '#blueprints';
+
+const blueprintDefinition = Capability.makeModule<
+  [],
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]
+>(() => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, ThreadBlueprint)]));
+
+export default blueprintDefinition;

package/src/capabilities/{call-manager/call-manager.ts → call-manager.ts}

@@ -5,10 +5,11 @@
 import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import { ClientCapabilities } from '@dxos/plugin-client';
+import { ClientCapabilities } from '@dxos/plugin-client/types';
 
-import { CallManager } from '../../calls';
-import { ThreadCapabilities } from '../../types';
+import { ThreadCapabilities } from '#types';
+
+import { CallManager } from '../calls';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {

package/src/capabilities/create-object.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
+import { SpaceCapabilities } from '@dxos/plugin-space/types';
+import { Channel } from '@dxos/types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+      id: Channel.Channel.typename,
+      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,
+          });
+        }),
+    });
+  }),
+);

package/src/capabilities/index.ts

@@ -2,13 +2,21 @@
 // Copyright 2025 DXOS.org
 //
 
-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';
+import { Capability } from '@dxos/app-framework';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint, OperationHandlerSet } from '@dxos/compute';
+
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
+export const CallManager = Capability.lazy('CallManager', () => import('./call-manager'));
+export const Markdown = Capability.lazy('Markdown', () => import('./markdown'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const ReactRoot = Capability.lazy('ReactRoot', () => import('./react-root'));
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));
+export const ThreadSettings = Capability.lazy('ThreadSettings', () => import('./settings'));
+export const ThreadState = Capability.lazy('ThreadState', () => import('./state'));
+export const UndoMappings = Capability.lazy('UndoMappings', () => import('./undo-mappings'));

package/src/capabilities/{markdown/markdown.ts → markdown.ts}

@@ -6,13 +6,14 @@ import { EditorView } from '@codemirror/view';
 import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } 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 { LayoutOperation } from '@dxos/app-toolkit';
+import { MarkdownCapabilities } from '@dxos/plugin-markdown/types';
+import { linkedSegment } from '@dxos/react-ui-attention';
+import { type EditorState, commentClickedEffect, commentsState, documentId, overlap } from '@dxos/ui-editor';
 
-import { threads } from '../../extensions';
-import { ThreadCapabilities } from '../../types';
+import { ThreadCapabilities } from '#types';
+
+import { threads } from '../extensions';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
@@ -27,34 +28,36 @@ export default Capability.makeModule(
         return threads({ registry, stateAtom }, doc, invokePromise);
       },
       ({ document: doc }) => {
-        if (!doc) return [];
+        if (!doc) {
+          return [];
+        }
         const registry = capabilities.get(Capabilities.AtomRegistry);
         const stateAtom = capabilities.get(ThreadCapabilities.State);
 
         return EditorView.updateListener.of((update) => {
           if (update.docChanged || update.selectionSet) {
-            const objectId = Obj.getDXN(doc).toString();
+            const id = update.state.facet(documentId);
             const overlaps = selectionOverlapsComment(update.state);
             const current = registry.get(stateAtom);
             registry.set(stateAtom, {
               ...current,
-              toolbar: { ...current.toolbar, [objectId]: overlaps },
+              toolbar: { ...current.toolbar, [id]: overlaps },
             });
           }
         });
       },
       ({ document: doc }) => {
-        if (!doc) return [];
+        if (!doc) {
+          return [];
+        }
         const { invokePromise } = capabilities.get(Capabilities.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`,
+                void invokePromise(LayoutOperation.UpdateCompanion, {
+                  subject: linkedSegment('comments'),
                 });
               }
             });

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/compute';
+
+import { ThreadOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, ThreadOperationHandlerSet);
+  }),
+);

package/src/capabilities/{react-root/react-root.tsx → react-root.tsx}

@@ -7,8 +7,8 @@ import React from 'react';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 
-import { Call } from '../../components';
-import { meta } from '../../meta';
+import { Call } from '#components';
+import { meta } from '#meta';
 
 export default Capability.makeModule(() =>
   Effect.sync(() => {

package/src/capabilities/react-surface.tsx

@@ -0,0 +1,97 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useCapability, useSettingsState } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { getSpace } from '@dxos/react-client/echo';
+import { Channel, Thread } from '@dxos/types';
+
+import { ThreadSettings } from '#components';
+import {
+  CallDebugPanel,
+  CallSidebar,
+  ChannelChat,
+  ChannelContainer,
+  ThreadCompanion,
+  ThreadContainer,
+} from '#containers';
+import { meta } from '#meta';
+import { ThreadCapabilities, type Settings } from '#types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: 'channel',
+        filter: AppSurface.object(AppSurface.Article, Channel.Channel),
+        component: ({ data: { subject, attendableId }, role }) => (
+          <ChannelContainer role={role} subject={subject} attendableId={attendableId} />
+        ),
+      }),
+      Surface.create({
+        id: 'chat-companion',
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'chat'),
+          AppSurface.companion(AppSurface.Article, Channel.Channel),
+        ),
+        component: ({ data: { companionTo: channel } }) => {
+          const space = getSpace(channel);
+          if (!space) {
+            return null;
+          }
+
+          return <ChannelChat channel={channel} space={space} />;
+        },
+      }),
+      Surface.create({
+        id: 'thread',
+        filter: AppSurface.object(AppSurface.Article, Thread.Thread),
+        component: ({ data: { subject } }) => {
+          const space = getSpace(subject);
+          if (!space || !subject) {
+            return null;
+          }
+
+          return <ThreadContainer thread={subject} space={space} />;
+        },
+      }),
+      Surface.create({
+        id: 'comments',
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'comments'),
+          AppSurface.companion(AppSurface.Article),
+        ),
+        // TODO(wittjosiah): This isn't scrolling properly in a plank.
+        component: ({ data }) => <ThreadCompanion attendableId={data.attendableId} subject={data.companionTo} />,
+      }),
+      Surface.create({
+        id: 'plugin-settings',
+        filter: AppSurface.settings(AppSurface.Article, meta.id),
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<Settings.Settings>(subject.atom);
+          return <ThreadSettings settings={settings} onSettingsChange={updateSettings} />;
+        },
+      }),
+      Surface.create({
+        id: 'assistant',
+        role: 'deck-companion--active-call',
+        component: () => <CallSidebar />,
+      }),
+      Surface.create({
+        id: 'devtools-overview',
+        role: 'devtools-overview',
+        component: () => {
+          const call = useCapability(ThreadCapabilities.CallManager);
+          const state = useAtomValue(call.stateAtom);
+          return <CallDebugPanel state={state} />;
+        },
+      }),
+    ]),
+  ),
+);

package/src/capabilities/{settings/settings.ts → settings.ts}

@@ -8,15 +8,16 @@ import { Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
 import { createKvsStore } from '@dxos/effect';
 
-import { meta } from '../../meta';
-import { ThreadSettingsSchema } from '../../types';
-import { ThreadCapabilities } from '../../types/capabilities';
+import { meta } from '#meta';
+import { Settings } from '#types';
+
+import { ThreadCapabilities } from '../types/capabilities';
 
 export default Capability.makeModule(() =>
   Effect.sync(() => {
     const settingsAtom = createKvsStore({
       key: meta.id,
-      schema: ThreadSettingsSchema,
+      schema: Settings.Settings,
       defaultValue: () => ({}),
     });
 
@@ -26,7 +27,7 @@ export default Capability.makeModule(() =>
       // Contribute to common settings for UI discovery.
       Capability.contributes(AppCapabilities.Settings, {
         prefix: meta.id,
-        schema: ThreadSettingsSchema,
+        schema: Settings.Settings,
         atom: settingsAtom,
       }),
     ];

package/src/capabilities/{state/state.ts → state.ts}

@@ -7,7 +7,7 @@ import * as Effect from 'effect/Effect';
 
 import { Capability } from '@dxos/app-framework';
 
-import { ThreadCapabilities, type ThreadState, type ViewStore } from '../../types';
+import { ThreadCapabilities, type ThreadState, type ViewStore } from '#types';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {

package/src/capabilities/undo-mappings.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability, UndoMapping } from '@dxos/app-framework';
+
+import { meta } from '#meta';
+import { ThreadOperation } from '#operations';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.UndoMapping, [
+      UndoMapping.make({
+        operation: ThreadOperation.Delete,
+        inverse: ThreadOperation.Restore,
+        deriveContext: (_input, output) => {
+          if (!output.thread || !output.anchor) {
+            return;
+          }
+          return {
+            thread: output.thread,
+            anchor: output.anchor,
+          };
+        },
+        message: ['thread-deleted.label', { ns: meta.id }],
+      }),
+      UndoMapping.make({
+        operation: ThreadOperation.DeleteMessage,
+        inverse: ThreadOperation.RestoreMessage,
+        deriveContext: (input, output) => {
+          if (!output.message || output.messageIndex === undefined) {
+            return;
+          }
+          return {
+            anchor: input.anchor,
+            message: output.message,
+            messageIndex: output.messageIndex,
+          };
+        },
+        message: ['message-deleted.label', { ns: meta.id }],
+      }),
+    ]);
+  }),
+);

package/src/components/Call/Call.tsx

@@ -3,16 +3,16 @@
 //
 
 import { useAtomValue } from '@effect-atom/atom-react';
-import React, { type FC, type PropsWithChildren } from 'react';
+import React, { type PropsWithChildren } from 'react';
 
 import { useCapability } from '@dxos/app-framework/ui';
 import { type ThemedClassName } from '@dxos/react-ui';
 
-import { useDebugMode } from '../../hooks';
-import { ThreadCapabilities } from '../../types';
+import { useDebugMode } from '#hooks';
+import { ThreadCapabilities } from '#types';
+
 import { AudioStream } from '../Media';
 import { ParticipantGrid } from '../Participant';
-
 import { Toolbar, type ToolbarProps } from './Toolbar';
 
 //
@@ -21,8 +21,8 @@ import { Toolbar, type ToolbarProps } from './Toolbar';
 
 type CallRootProps = PropsWithChildren<ThemedClassName>;
 
-const CallRoot: FC<CallRootProps> = ({ children }) => {
-  return <div className='relative flex flex-col grow overflow-hidden'>{children}</div>;
+const CallRoot = ({ children }: CallRootProps) => {
+  return <div className='relative dx-container flex flex-col'>{children}</div>;
 };
 
 CallRoot.displayName = 'CallRoot';
@@ -33,7 +33,7 @@ CallRoot.displayName = 'CallRoot';
 
 type CallAudioProps = {};
 
-const CallAudio: FC<CallAudioProps> = () => {
+const CallAudio = (_props: CallAudioProps) => {
   const call = useCapability(ThreadCapabilities.CallManager);
   const audioTracksToPlay = useAtomValue(call.audioTracksToPlayAtom);
 
@@ -50,7 +50,7 @@ type CallGridProps = {
   fullscreen?: boolean;
 };
 
-const CallGrid: FC<CallGridProps> = ({ fullscreen }) => {
+const CallGrid = ({ fullscreen }: CallGridProps) => {
   const debug = useDebugMode();
   const call = useCapability(ThreadCapabilities.CallManager);
   const self = useAtomValue(call.selfAtom);
@@ -71,7 +71,7 @@ CallGrid.displayName = 'CallGrid';
 
 type CallToolbarProps = Pick<ToolbarProps, 'channel' | 'onLeave'>;
 
-const CallToolbar: FC<CallToolbarProps> = (props) => {
+const CallToolbar = (props: CallToolbarProps) => {
   return (
     <div className='absolute bottom-0 left-0 right-0 flex justify-center'>
       <Toolbar isInRoom {...props} />