@dxos/plugin-thread 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/src/testing/stories.ts

@@ -2,30 +2,32 @@
 // Copyright 2023 DXOS.org
 //
 
-import { IntentPlugin, SettingsPlugin } from '@dxos/app-framework';
-import { Obj } from '@dxos/echo';
+import * as Effect from 'effect/Effect';
+
+import { OperationPlugin, type Plugin } from '@dxos/app-framework';
 import { ClientPlugin } from '@dxos/plugin-client';
 import { GraphPlugin } from '@dxos/plugin-graph';
+import { SettingsPlugin } from '@dxos/plugin-settings';
 import { SpacePlugin } from '@dxos/plugin-space';
 import { ThemePlugin } from '@dxos/plugin-theme';
 import { Config } from '@dxos/react-client';
-import { Ref } from '@dxos/react-client/echo';
-import { defaultTx } from '@dxos/react-ui-theme';
+import { defaultTx } from '@dxos/ui-theme';
 
 import { ThreadPlugin } from '../ThreadPlugin';
-import { ChannelType, ThreadType } from '../types';
+import { Channel } from '../types';
 
-export const createThreadPlugins = async () => [
+export const createThreadPlugins = async (): Promise<Array<Plugin.Plugin>> => [
   ThemePlugin({ tx: defaultTx }),
   ClientPlugin({
-    onClientInitialized: async ({ client }) => {
-      await client.halo.createIdentity({ displayName: 'Test User' });
-    },
-    onSpacesReady: async ({ client }) => {
-      await client.spaces.default.waitUntilReady();
-      const thread = Obj.make(ThreadType, { messages: [] });
-      client.spaces.default.db.add(Obj.make(ChannelType, { defaultThread: Ref.make(thread), threads: [] }));
-    },
+    onClientInitialized: ({ client }) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => client.halo.createIdentity({ displayName: 'Test User' }));
+      }),
+    onSpacesReady: ({ client }) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => client.spaces.default.waitUntilReady());
+        client.spaces.default.db.add(Channel.make());
+      }),
     config: new Config({
       runtime: {
         client: {
@@ -47,7 +49,7 @@ export const createThreadPlugins = async () => [
     }),
   }),
   SpacePlugin({}),
-  IntentPlugin(),
+  OperationPlugin(),
   SettingsPlugin(),
   GraphPlugin(),
   ThreadPlugin(),

package/src/translations.ts

@@ -2,15 +2,16 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Type } from '@dxos/echo';
 import { type Resource } from '@dxos/react-ui';
 
 import { meta } from './meta';
-import { ChannelType } from './types';
+import { Channel } from './types';
 
 export const translations = [
   {
     'en-US': {
-      [ChannelType.typename]: {
+      [Type.getTypename(Channel.Channel)]: {
         'typename label': 'Channel',
         'typename label_zero': 'Channels',
         'typename label_one': 'Channel',
@@ -18,6 +19,7 @@ export const translations = [
         'object name placeholder': 'New channel',
         'rename object label': 'Rename channel',
         'delete object label': 'Delete channel',
+        'object deleted label': 'Channel deleted',
       },
       [meta.id]: {
         'plugin name': 'Chat',
@@ -49,6 +51,7 @@ export const translations = [
         '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',
@@ -59,7 +62,7 @@ export const translations = [
         'set display name label': 'Continue',
 
         'call tab label': 'Call',
-        'meeting status title': 'Meeting',
+        'meeting status title': 'Calls',
         'share meeting link label': 'Share meeting',
         'show webrtc stats title': 'WebRTC Stats',
         'show calls history title': 'Service History',

package/src/types/Channel.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Obj, Ref, Type } from '@dxos/echo';
+import { FormInputAnnotation } from '@dxos/echo/internal';
+import { Thread } from '@dxos/types';
+
+export const Channel = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  defaultThread: Ref.Ref(Thread.Thread).pipe(FormInputAnnotation.set(false)),
+  // TODO(wittjosiah): Should be an "ordered collection".
+  threads: Ref.Ref(Thread.Thread).pipe(Schema.Array, FormInputAnnotation.set(false)),
+}).pipe(
+  Type.object({
+    typename: 'dxos.org/type/Channel',
+    version: '0.1.0',
+  }),
+);
+
+export interface Channel extends Schema.Schema.Type<typeof Channel> {}
+
+export const make = (props: Pick<Obj.MakeProps<typeof Channel>, 'name'> = {}) =>
+  Obj.make(Channel, {
+    ...props,
+    defaultThread: Ref.make(Obj.make(Thread.Thread, { messages: [], status: 'active' })),
+    threads: [],
+  });

package/src/types/capabilities.ts

@@ -0,0 +1,34 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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';
+
+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`);
+
+  // 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?
+  // TODO(wittjosiah): These callbacks could be intents once we support broadcast.
+  export type CallProperties = {
+    onJoin: (state: { channel?: Channel.Channel; roomId?: string }) => Promise<void>;
+    onLeave: (roomId?: string) => Promise<void>;
+    onCallStateUpdated: (callState: CallState) => Promise<void>;
+    onMediaStateUpdated: ([mediaState, isSpeaking]: [MediaState, boolean]) => Promise<void>;
+  };
+
+  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`);
+
+  /** Per-subject view state (e.g., showResolvedThreads). */
+  export const ViewState = Capability.make<Atom.Writable<ViewStore>>(`${meta.id}/capability/view-state`);
+}

package/src/types/index.ts

@@ -2,5 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './schema';
+export * from './capabilities';
+export * as Channel from './Channel';
 export * from './types';

package/src/types/types.ts

@@ -4,114 +4,192 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Type } from '@dxos/echo';
-import { EchoObjectSchema, SpaceSchema } from '@dxos/react-client/echo';
-import { AnchoredTo, DataType } from '@dxos/schema';
+import { Capability } from '@dxos/app-framework';
+import { Key, Obj } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { SpaceSchema } from '@dxos/react-client/echo';
+import { Actor, AnchoredTo, Message, Thread } from '@dxos/types';
 
 import { meta } from '../meta';
 
-import { ChannelType, ThreadType } from './schema';
+import * as Channel from './Channel';
 
-export namespace ThreadAction {
-  export class onCreateSpace extends Schema.TaggedClass<onCreateSpace>()(`${meta.id}/action/on-space-created`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-      rootCollection: DataType.Collection,
-    }),
-    output: Schema.Void,
-  }) {}
+const THREAD_OPERATION = `${meta.id}/operation`;
 
-  export class CreateChannel extends Schema.TaggedClass<CreateChannel>()(`${meta.id}/action/create-channel`, {
-    input: Schema.Struct({
-      spaceId: Type.SpaceId,
-      name: Schema.optional(Schema.String),
-    }),
-    output: Schema.Struct({
-      object: ChannelType,
-    }),
-  }) {}
+/**
+ * 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 class CreateChannelThread extends Schema.TaggedClass<CreateChannelThread>()(
-    `${meta.id}/action/create-channel-thread`,
-    {
+  export const CreateChannel = Operation.make({
+    meta: { key: `${THREAD_OPERATION}/create-channel`, name: 'Create Channel' },
+    services: [Capability.Service],
+    schema: {
       input: Schema.Struct({
-        channel: ChannelType,
+        spaceId: Key.SpaceId,
+        name: Schema.optional(Schema.String),
       }),
       output: Schema.Struct({
-        object: ThreadType,
+        object: Channel.Channel,
       }),
     },
-  ) {}
+  });
 
-  export class Create extends Schema.TaggedClass<Create>()(`${meta.id}/action/create`, {
-    input: Schema.Struct({
-      name: Schema.optional(Schema.String),
-      anchor: Schema.optional(Schema.String),
-      subject: EchoObjectSchema,
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class Delete extends Schema.TaggedClass<Delete>()(`${meta.id}/action/delete`, {
-    input: Schema.Struct({
-      anchor: AnchoredTo,
-      subject: EchoObjectSchema,
-      thread: Schema.optional(ThreadType),
-    }),
-    output: Schema.Void,
-  }) {}
+  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 class Select extends Schema.TaggedClass<Select>()(`${meta.id}/action/select`, {
-    input: Schema.Struct({
-      current: Schema.String,
-    }),
-    output: Schema.Void,
-  }) {}
+  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: Obj.Unknown,
+      }),
+      output: Schema.Void,
+    },
+  });
 
-  export class ToggleResolved extends Schema.TaggedClass<ToggleResolved>()(`${meta.id}/action/toggle-resolved`, {
-    input: Schema.Struct({
-      thread: ThreadType,
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class AddProposal extends Schema.TaggedClass<AddProposal>()(`${meta.id}/action/add-proposal`, {
-    input: Schema.Struct({
-      text: Schema.String,
-      anchor: Schema.String,
-      sender: DataType.Actor,
-      subject: EchoObjectSchema,
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class AddMessage extends Schema.TaggedClass<AddMessage>()(`${meta.id}/action/add-message`, {
-    input: Schema.Struct({
-      subject: EchoObjectSchema,
-      anchor: AnchoredTo,
-      sender: DataType.Actor,
-      text: Schema.String,
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class DeleteMessage extends Schema.TaggedClass<DeleteMessage>()(`${meta.id}/action/delete-message`, {
-    input: Schema.Struct({
-      anchor: AnchoredTo,
-      subject: EchoObjectSchema,
-      messageId: Schema.String,
-      message: Schema.optional(DataType.Message),
-      messageIndex: Schema.optional(Schema.Number),
+  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: Obj.Unknown,
+        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: Obj.Unknown,
+        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.' }),
     }),
-    output: Schema.Void,
-  }) {}
+  );
+
+  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: Obj.Unknown,
+        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 interface ThreadModel {
-  root: ThreadType;
+  root: Thread.Thread;
 }
 
 type SubjectId = string;
@@ -122,6 +200,7 @@ export type ThreadState = {
   /** Object toolbar state. */
   toolbar: Record<string, boolean>;
   /** In-memory draft threads. */
-  drafts: Record<string, AnchoredTo[]>;
+  // TODO(burdon): Drafts are getting lost.
+  drafts: Record<string, AnchoredTo.AnchoredTo[]>;
   current?: string | undefined;
 };

package/dist/lib/browser/ChannelContainer-BGDGZHV4.mjs

@@ -1,16 +0,0 @@
-import {
-  ChannelContainer,
-  ChannelContainer_default
-} from "./chunk-CMCVHULC.mjs";
-import "./chunk-2MUYQOQE.mjs";
-import "./chunk-L326LSNS.mjs";
-import "./chunk-B7YQ7QR2.mjs";
-import "./chunk-HDEQRBOC.mjs";
-import "./chunk-CP7E2HRE.mjs";
-import "./chunk-XYUJXHYV.mjs";
-import "./chunk-T4KJ5JR4.mjs";
-export {
-  ChannelContainer,
-  ChannelContainer_default as default
-};
-//# sourceMappingURL=ChannelContainer-BGDGZHV4.mjs.map

package/dist/lib/browser/ChatContainer-75KJZ4XR.mjs

@@ -1,15 +0,0 @@
-import {
-  ChatContainer,
-  ChatContainer_default,
-  ChatHeading
-} from "./chunk-B7YQ7QR2.mjs";
-import "./chunk-HDEQRBOC.mjs";
-import "./chunk-CP7E2HRE.mjs";
-import "./chunk-XYUJXHYV.mjs";
-import "./chunk-T4KJ5JR4.mjs";
-export {
-  ChatContainer,
-  ChatHeading,
-  ChatContainer_default as default
-};
-//# sourceMappingURL=ChatContainer-75KJZ4XR.mjs.map

package/dist/lib/browser/app-graph-builder-ODKIAXR7.mjs

@@ -1,171 +0,0 @@
-import {
-  ChannelType,
-  ThreadAction
-} from "./chunk-VTYX3SIM.mjs";
-import {
-  ThreadCapabilities
-} from "./chunk-L326LSNS.mjs";
-import {
-  getAnchor
-} from "./chunk-CP7E2HRE.mjs";
-import {
-  meta
-} from "./chunk-T4KJ5JR4.mjs";
-
-// src/capabilities/app-graph-builder.ts
-import { Rx } from "@effect-rx/rx-react";
-import * as Function from "effect/Function";
-import * as Option from "effect/Option";
-import { Capabilities, contributes, createIntent } from "@dxos/app-framework";
-import { Obj } from "@dxos/echo";
-import { AttentionCapabilities } from "@dxos/plugin-attention";
-import { ATTENDABLE_PATH_SEPARATOR, DECK_COMPANION_TYPE, PLANK_COMPANION_TYPE } from "@dxos/plugin-deck/types";
-import { ROOT_ID, createExtension, rxFromSignal } from "@dxos/plugin-graph";
-import { fullyQualifiedId } from "@dxos/react-client/echo";
-var app_graph_builder_default = ((context) => {
-  const resolve = (typename) => context.getCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
-  return contributes(Capabilities.AppGraphBuilder, [
-    createExtension({
-      id: `${meta.id}/active-call`,
-      connector: (node) => Rx.make((get) => Function.pipe(get(node), Option.flatMap((node2) => node2.id === ROOT_ID ? Option.some(node2) : Option.none()), Option.map((node2) => {
-        const [call] = get(context.capabilities(ThreadCapabilities.CallManager));
-        return get(rxFromSignal(() => call?.joined ? [
-          {
-            id: `${node2.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"
-            }
-          }
-        ] : []));
-      }), Option.getOrElse(() => [])))
-    }),
-    // TODO(wittjosiah): The channel shouldn't become the companion during a call.
-    //   Alternative: the call/meeting/thread should be a child node of the channel and that should be opened.
-    createExtension({
-      id: `${meta.id}/channel-chat-companion`,
-      connector: (node) => {
-        return Rx.make((get) => {
-          return Function.pipe(get(node), Option.flatMap((node2) => Obj.instanceOf(ChannelType, node2.data) ? Option.some(node2.data) : Option.none()), Option.map((channel) => {
-            const callManager = context.getCapability(ThreadCapabilities.CallManager);
-            const joined = get(rxFromSignal(() => callManager.joined && callManager.roomId === fullyQualifiedId(channel)));
-            if (!joined) {
-              return [];
-            }
-            return [
-              {
-                id: `${fullyQualifiedId(channel)}${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"
-                }
-              }
-            ];
-          }), Option.getOrElse(() => []));
-        });
-      }
-    }),
-    createExtension({
-      id: `${meta.id}/comments-companion`,
-      connector: (node) => Rx.make((get) => Function.pipe(get(node), Option.flatMap((node2) => {
-        if (!Obj.isObject(node2.data) || Obj.instanceOf(ChannelType, node2.data)) {
-          return Option.none();
-        }
-        const metadata = resolve(Obj.getTypename(node2.data));
-        return typeof metadata.comments === "string" ? Option.some(node2) : Option.none();
-      }), Option.map((node2) => [
-        {
-          id: [
-            node2.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"
-          }
-        }
-      ]), Option.getOrElse(() => [])))
-    }),
-    createExtension({
-      id: `${meta.id}/comment-toolbar`,
-      actions: (node) => Rx.make((get) => Function.pipe(get(node), Option.flatMap((node2) => {
-        if (!Obj.isObject(node2.data) || Obj.instanceOf(ChannelType, node2.data)) {
-          return Option.none();
-        }
-        const metadata = resolve(Obj.getTypename(node2.data));
-        return typeof metadata.comments === "string" ? Option.some(node2.data) : Option.none();
-      }), Option.map((object) => {
-        const selectionManager = context.getCapability(AttentionCapabilities.Selection);
-        const toolbar = get(context.capabilities(ThreadCapabilities.State))[0]?.state.toolbar ?? {};
-        const disabled = get(rxFromSignal(() => {
-          const metadata = resolve(Obj.getTypename(object));
-          const selection = selectionManager.getSelection(fullyQualifiedId(object), metadata.selectionMode);
-          const anchor = getAnchor(selection);
-          const invalidSelection = !anchor;
-          const overlappingComment = toolbar[fullyQualifiedId(object)];
-          return metadata.comments === "anchored" && invalidSelection || overlappingComment;
-        }));
-        return [
-          {
-            id: `${fullyQualifiedId(object)}/comment`,
-            data: () => {
-              const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-              const metadata = resolve(Obj.getTypename(object));
-              const selection = selectionManager.getSelection(fullyQualifiedId(object));
-              const anchor = metadata.comments === "anchored" ? getAnchor(selection) : Date.now().toString();
-              const name = metadata.getAnchorLabel?.(object, anchor);
-              void dispatch(createIntent(ThreadAction.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"
-            }
-          }
-        ];
-      }), Option.getOrElse(() => [])))
-    })
-  ]);
-});
-export {
-  app_graph_builder_default as default
-};
-//# sourceMappingURL=app-graph-builder-ODKIAXR7.mjs.map