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

package/src/operations/restore-message.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Obj, Ref, Relation } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+import { Thread } from '@dxos/types';
+
+import { RestoreMessage } from './definitions';
+
+const handler: Operation.WithHandler<typeof RestoreMessage> = RestoreMessage.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ anchor, message, messageIndex }) {
+      const thread = Relation.getSource(anchor) as Thread.Thread;
+      const db = Obj.getDatabase(thread);
+      invariant(db, 'Database not found');
+
+      Obj.change(thread, (obj) => {
+        obj.messages.splice(messageIndex, 0, Ref.make(message));
+      });
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'threads.message.undo-delete',
+        properties: {
+          spaceId: db.spaceId,
+          threadId: thread.id,
+          messageId: message.id,
+        },
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/restore.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { sleep } from '@dxos/async';
+import { Obj } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+
+import { Restore } from './definitions';
+
+const handler: Operation.WithHandler<typeof Restore> = Restore.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ thread, anchor }) {
+      const db = Obj.getDatabase(thread);
+      if (!db) {
+        return;
+      }
+
+      // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
+      db.add(thread);
+      yield* Effect.promise(() => sleep(100));
+      db.add(anchor);
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'threads.undo-delete',
+        properties: {
+          spaceId: db.spaceId,
+          threadId: thread.id,
+        },
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/select.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/operation';
+
+import { Select } from './definitions';
+
+import { ThreadCapabilities } from '../types';
+
+const handler: Operation.WithHandler<typeof Select> = Select.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const registry = yield* Capability.get(Capabilities.AtomRegistry);
+      const stateAtom = yield* Capability.get(ThreadCapabilities.State);
+      const current = registry.get(stateAtom);
+      registry.set(stateAtom, { ...current, current: input.current });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/toggle-resolved.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Obj } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+
+import { ToggleResolved } from './definitions';
+
+const handler: Operation.WithHandler<typeof ToggleResolved> = ToggleResolved.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const thread = input.thread;
+
+      Obj.change(thread, (obj) => {
+        if (obj.status === 'active' || obj.status === undefined) {
+          obj.status = 'resolved';
+        } else if (obj.status === 'resolved') {
+          obj.status = 'active';
+        }
+      });
+
+      const db = Obj.getDatabase(thread);
+      invariant(db, 'Database not found');
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'threads.toggle-resolved',
+        properties: {
+          spaceId: db.spaceId,
+          threadId: thread.id,
+        },
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/testing/stories.ts

@@ -4,19 +4,17 @@
 
 import * as Effect from 'effect/Effect';
 
-import { OperationPlugin, type Plugin, SettingsPlugin } from '@dxos/app-framework';
+import { type Plugin } from '@dxos/app-framework';
 import { ClientPlugin } from '@dxos/plugin-client';
-import { GraphPlugin } from '@dxos/plugin-graph';
 import { SpacePlugin } from '@dxos/plugin-space';
-import { ThemePlugin } from '@dxos/plugin-theme';
 import { Config } from '@dxos/react-client';
-import { defaultTx } from '@dxos/ui-theme';
+import { corePlugins } from '@dxos/plugin-testing';
 
 import { ThreadPlugin } from '../ThreadPlugin';
-import { Channel } from '../types';
+import { Channel } from '#types';
 
 export const createThreadPlugins = async (): Promise<Array<Plugin.Plugin>> => [
-  ThemePlugin({ tx: defaultTx }),
+  ...corePlugins(),
   ClientPlugin({
     onClientInitialized: ({ client }) =>
       Effect.gen(function* () {
@@ -24,8 +22,8 @@ export const createThreadPlugins = async (): Promise<Array<Plugin.Plugin>> => [
       }),
     onSpacesReady: ({ client }) =>
       Effect.gen(function* () {
-        yield* Effect.promise(() => client.spaces.default.waitUntilReady());
-        client.spaces.default.db.add(Channel.make());
+        const space = client.spaces.get()[0];
+        space.db.add(Channel.make());
       }),
     config: new Config({
       runtime: {
@@ -48,8 +46,5 @@ export const createThreadPlugins = async (): Promise<Array<Plugin.Plugin>> => [
     }),
   }),
   SpacePlugin({}),
-  OperationPlugin(),
-  SettingsPlugin(),
-  GraphPlugin(),
   ThreadPlugin(),
 ];

package/src/translations.ts

@@ -5,96 +5,92 @@
 import { Type } from '@dxos/echo';
 import { type Resource } from '@dxos/react-ui';
 
-import { meta } from './meta';
-import { Channel } from './types';
+import { meta } from '#meta';
+import { Channel } from '#types';
 
 export const translations = [
   {
     'en-US': {
       [Type.getTypename(Channel.Channel)]: {
-        'typename label': 'Channel',
-        'typename label_zero': 'Channels',
-        'typename label_one': 'Channel',
-        'typename label_other': 'Channels',
-        'object name placeholder': 'New channel',
-        'rename object label': 'Rename channel',
-        'delete object label': 'Delete channel',
-        'object deleted label': 'Channel deleted',
+        'typename.label': 'Channel',
+        'typename.label_zero': 'Channels',
+        'typename.label_one': 'Channel',
+        'typename.label_other': 'Channels',
+        'object-name.placeholder': 'New channel',
+        'add-object.label': 'Add channel',
+        'rename-object.label': 'Rename channel',
+        'delete-object.label': 'Delete channel',
+        'object-deleted.label': 'Channel deleted',
       },
       [meta.id]: {
-        'plugin name': 'Chat',
-        'channel title label': 'Title',
-        'message placeholder': 'Reply…',
-        'activity message': 'Processing…',
-        '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':
+        'plugin.name': 'Chat',
+        'channel-title.label': 'Title',
+        'message.placeholder': 'Reply…',
+        'activity.message': 'Processing…',
+        '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',
-        'accept proposal label': 'Accept proposal',
-        'open comments panel label': 'Show Comments',
-        'comments label': 'Comments',
-        'show all label': 'All comments',
-        'show unresolved label': 'Unresolved comments',
-        'add comment label': 'Add comment',
+        'toggle-show-resolved.label': 'Show resolved',
+        'unnamed-object-threads.label': 'Threads',
+        'mark-as-resolved.label': 'Mark as resolved',
+        'mark-as-unresolved.label': 'Mark as unresolved',
+        'save-message.label': 'Save',
+        'edit-message.label': 'Edit',
+        'delete-message.label': 'Delete message',
+        'accept-proposal.label': 'Accept proposal',
+        'open-comments-panel.label': 'Show Comments',
+        'comments.label': 'Comments',
+        'show-all.label': 'All comments',
+        'show-unresolved.label': 'Unresolved comments',
+        'add-comment.label': 'Add comment',
 
-        'channel companion label': 'Channel',
-        'call panel label': 'Active Call',
+        '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',
+        'display-name.label': 'Display name',
+        'display-name.description': 'Set your display name before joining a meeting.',
+        'display-name-input.placeholder': 'Enter your name',
+        'set-display-name.label': 'Continue',
 
-        'call tab label': 'Call',
-        'meeting status title': 'Calls',
-        'share meeting link label': 'Share meeting',
-        'show webrtc stats title': 'WebRTC Stats',
-        'show calls history title': 'Service History',
+        'call-tab.label': 'Call',
+        'meeting-status.title': 'Calls',
+        'share-meeting-link.label': 'Share meeting',
+        'show-webrtc-stats.title': 'WebRTC Stats',
+        'show-calls-history.title': 'Service History',
 
-        'meeting summary label': 'Summary',
-        'summarize label': 'Summarize',
-        'summarizing label': 'Creating summary...',
-        'create summary message': 'A summary doesn’t exist for this meeting yet. Create one now?',
+        'meeting-summary.label': 'Summary',
+        'summarize.label': 'Summarize',
+        'summarizing.label': 'Creating summary...',
+        'create-summary.message': 'A summary doesn’t exist for this meeting yet. Create one now?',
 
-        'join call': 'Join',
-        'leave call': 'Leave',
+        'icon-pin.label': 'Pin video',
+        'icon-unpin.label': 'Unpin video',
+        'icon-wave.label': 'Waving',
+        'icon-muted.label': 'Muted',
+        'join-call.button': 'Join',
+        'leave-call.button': 'Leave',
+        'mic-on.button': 'Unmute',
+        'mic-off.button': 'Mute',
+        'camera-on.button': 'Turn camera on',
+        'camera-off.button': 'Turn camera off',
+        'camera-off.label': 'Camera off',
+        'raise-hand.button': 'Raise hand',
+        'lower-hand.button': 'Lower hand',
+        'screenshare-on.button': 'Share screen',
+        'screenshare-off.button': 'Stop streaming',
 
-        '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',
+        'channel-toolbar.title': 'Channel actions',
+        'start-video-call.menu': 'Start video call',
       },
     },
   },

package/src/types/Channel.ts

@@ -2,22 +2,29 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Schema from 'effect/Schema';
 
-import { Obj, Ref, Type } from '@dxos/echo';
+import { Annotation, Obj, Ref, Type } from '@dxos/echo';
 import { FormInputAnnotation } from '@dxos/echo/internal';
 import { Thread } from '@dxos/types';
 
+// TODO(burdon): What is the difference between Thread and Channel.
 export const Channel = Schema.Struct({
   name: Schema.optional(Schema.String),
-  defaultThread: Type.Ref(Thread.Thread).pipe(FormInputAnnotation.set(false)),
+  defaultThread: Ref.Ref(Thread.Thread).pipe(FormInputAnnotation.set(false)),
   // TODO(wittjosiah): Should be an "ordered collection".
-  threads: Type.Ref(Thread.Thread).pipe(Schema.Array, FormInputAnnotation.set(false)),
+  threads: Ref.Ref(Thread.Thread).pipe(Schema.Array, FormInputAnnotation.set(false)),
 }).pipe(
   Type.object({
-    typename: 'dxos.org/type/Channel',
+    typename: 'org.dxos.type.channel',
     version: '0.1.0',
   }),
+  Annotation.IconAnnotation.set({
+    icon: 'ph--hash--regular',
+    hue: 'rose',
+  }),
 );
 
 export interface Channel extends Schema.Schema.Type<typeof Channel> {}

package/src/types/Settings.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+export const Settings = Schema.mutable(Schema.Struct({}));
+export type Settings = Schema.Schema.Type<typeof Settings>;

package/src/types/capabilities.ts

@@ -7,12 +7,13 @@ import { type Atom } from '@effect-atom/atom-react';
 import { Capability } from '@dxos/app-framework';
 
 import { type CallManager, type CallState, type MediaState } from '../calls';
-import { meta } from '../meta';
-import { type Channel, type ThreadSettingsProps, type ThreadState, type ViewStore } from '../types';
+import { meta } from '#meta';
+import { type Channel, type ThreadState, type ViewStore } from '../types';
+import * as Settings from './Settings';
 
 export namespace ThreadCapabilities {
-  export const Settings = Capability.make<Atom.Writable<ThreadSettingsProps>>(`${meta.id}/capability/settings`);
-  export const CallManager = Capability.make<CallManager>(`${meta.id}/capability/call-manager`);
+  export const Settings = Capability.make<Atom.Writable<Settings.Settings>>(`${meta.id}.capability.settings`);
+  export const CallManager = Capability.make<CallManager>(`${meta.id}.capability.call-manager`);
 
   // TODO(burdon): Better way to define specific extensions for meeting companions.
   // TODO(burdon): This brings in deps from ../calls; how should we manage/minimize explicit type exposure to other plugins?
@@ -24,11 +25,11 @@ export namespace ThreadCapabilities {
     onMediaStateUpdated: ([mediaState, isSpeaking]: [MediaState, boolean]) => Promise<void>;
   };
 
-  export const CallExtension = Capability.make<CallProperties>(`${meta.id}/capability/call-extension`);
+  export const CallExtension = Capability.make<CallProperties>(`${meta.id}.capability.call-extension`);
 
   /** Thread state (drafts, toolbar state, current selection). */
-  export const State = Capability.make<Atom.Writable<ThreadState>>(`${meta.id}/capability/state`);
+  export const State = Capability.make<Atom.Writable<ThreadState>>(`${meta.id}.capability.state`);
 
   /** Per-subject view state (e.g., showResolvedThreads). */
-  export const ViewState = Capability.make<Atom.Writable<ViewStore>>(`${meta.id}/capability/view-state`);
+  export const ViewState = Capability.make<Atom.Writable<ViewStore>>(`${meta.id}.capability.view-state`);
 }

package/src/types/types.ts

@@ -2,191 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-import * as Schema from 'effect/Schema';
+import { AnchoredTo, Thread } from '@dxos/types';
 
-import { Capability } from '@dxos/app-framework';
-import { Key, Type } from '@dxos/echo';
-import { Operation } from '@dxos/operation';
-import { SpaceSchema } from '@dxos/react-client/echo';
-import { Collection } from '@dxos/schema';
-import { Actor, AnchoredTo, Message, Thread } from '@dxos/types';
-
-import { meta } from '../meta';
-
-import * as Channel from './Channel';
-
-const THREAD_OPERATION = `${meta.id}/operation`;
-
-/**
- * Operations for the Thread plugin.
- * Note: Complex ECHO types are typed as Schema.Any to avoid serialization issues.
- */
-export namespace ThreadOperation {
-  export const OnCreateSpace = Operation.make({
-    meta: { key: `${THREAD_OPERATION}/on-create-space`, name: 'On Create Space' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        space: SpaceSchema,
-        rootCollection: Collection.Collection,
-        isDefault: Schema.Boolean.pipe(Schema.optional),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const CreateChannel = Operation.make({
-    meta: { key: `${THREAD_OPERATION}/create-channel`, name: 'Create Channel' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        spaceId: Key.SpaceId,
-        name: Schema.optional(Schema.String),
-      }),
-      output: Schema.Struct({
-        object: Channel.Channel,
-      }),
-    },
-  });
-
-  export const CreateChannelThread = Operation.make({
-    meta: { key: `${THREAD_OPERATION}/create-channel-thread`, name: 'Create Channel Thread' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        channel: Channel.Channel,
-      }),
-      output: Schema.Struct({
-        object: Thread.Thread,
-      }),
-    },
-  });
-
-  export const Create = Operation.make({
-    meta: { key: `${THREAD_OPERATION}/create`, name: 'Create Thread' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        name: Schema.optional(Schema.String),
-        anchor: Schema.optional(Schema.String),
-        subject: Type.Obj,
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const DeleteOutput = Schema.Struct({
-    thread: Thread.Thread.annotations({ description: 'The deleted thread.' }),
-    anchor: AnchoredTo.AnchoredTo.annotations({ description: 'The deleted anchor.' }),
-  }).pipe(Schema.partial);
-
-  export type DeleteOutput = Schema.Schema.Type<typeof DeleteOutput>;
-
-  export const Delete = Operation.make({
-    meta: { key: `${THREAD_OPERATION}/delete`, name: 'Delete Thread' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        anchor: AnchoredTo.AnchoredTo,
-        subject: Type.Obj,
-        thread: Schema.optional(Thread.Thread),
-      }),
-      output: DeleteOutput,
-    },
-  });
-
-  export const Select = Operation.make({
-    meta: { key: `${THREAD_OPERATION}/select`, name: 'Select Thread' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        current: Schema.String,
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const ToggleResolved = Operation.make({
-    meta: { key: `${THREAD_OPERATION}/toggle-resolved`, name: 'Toggle Resolved' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        thread: Thread.Thread,
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const AddMessage = Operation.make({
-    meta: { key: `${THREAD_OPERATION}/add-message`, name: 'Add Message' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        subject: Type.Obj,
-        anchor: AnchoredTo.AnchoredTo,
-        sender: Actor.Actor,
-        text: Schema.String,
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const DeleteMessageOutput = Schema.partial(
-    Schema.Struct({
-      message: Message.Message.annotations({ description: 'The deleted message.' }),
-      messageIndex: Schema.Number.annotations({ description: 'The index the message was at.' }),
-    }),
-  );
-
-  export type DeleteMessageOutput = Schema.Schema.Type<typeof DeleteMessageOutput>;
-
-  export const DeleteMessage = Operation.make({
-    meta: { key: `${THREAD_OPERATION}/delete-message`, name: 'Delete Message' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        anchor: AnchoredTo.AnchoredTo,
-        subject: Type.Obj,
-        messageId: Schema.String,
-      }),
-      output: DeleteMessageOutput,
-    },
-  });
-
-  /**
-   * Restore a deleted thread (inverse of Delete).
-   */
-  export const Restore = Operation.make({
-    meta: { key: `${THREAD_OPERATION}/restore`, name: 'Restore Thread' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        thread: Thread.Thread.annotations({ description: 'The thread to restore.' }),
-        anchor: AnchoredTo.AnchoredTo.annotations({ description: 'The anchor relation to restore.' }),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  /**
-   * Restore a deleted message (inverse of DeleteMessage).
-   */
-  export const RestoreMessage = Operation.make({
-    meta: { key: `${THREAD_OPERATION}/restore-message`, name: 'Restore Message' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        anchor: AnchoredTo.AnchoredTo.annotations({ description: 'The anchor of the thread.' }),
-        message: Message.Message.annotations({ description: 'The message to restore.' }),
-        messageIndex: Schema.Number.annotations({ description: 'The index to restore the message at.' }),
-      }),
-      output: Schema.Void,
-    },
-  });
-}
-
-export const ThreadSettingsSchema = Schema.mutable(Schema.Struct({}));
-export type ThreadSettingsProps = Schema.Schema.Type<typeof ThreadSettingsSchema>;
+export * as Settings from './Settings';
 
 export interface ThreadModel {
   root: Thread.Thread;

package/src/util.ts

@@ -5,7 +5,7 @@
 import * as Match from 'effect/Match';
 
 import { generateName } from '@dxos/display-name';
-import { type Selection } from '@dxos/plugin-attention';
+import { type Selection } from '@dxos/react-ui-attention';
 import { type PublicKey } from '@dxos/react-client';
 import { type Identity } from '@dxos/react-client/halo';
 import { type MessageMetadata } from '@dxos/react-ui-thread';