@dxos/plugin-thread 0.6.11 → 0.6.12-main.5cc132e

package/src/ThreadPlugin.tsx

@@ -21,17 +21,15 @@ import {
   SLUG_COLLECTION_INDICATOR,
   isLayoutParts,
   parseMetadataResolverPlugin,
-  type IntentDispatcher,
-  useResolvePlugins,
 } from '@dxos/app-framework';
 import { type UnsubscribeCallback } from '@dxos/async';
 import { type EchoReactiveObject, getTypename } from '@dxos/echo-schema';
 import { create } from '@dxos/echo-schema';
 import { LocalStorageStore } from '@dxos/local-storage';
+import { log } from '@dxos/log';
 import { type AttentionPluginProvides, parseAttentionPlugin } from '@dxos/plugin-attention';
 import { parseClientPlugin } from '@dxos/plugin-client';
 import { type ActionGroup, createExtension, isActionGroup } from '@dxos/plugin-graph';
-import { DocumentType } from '@dxos/plugin-markdown/types';
 import { ObservabilityAction } from '@dxos/plugin-observability/meta';
 import { SpaceAction } from '@dxos/plugin-space';
 import { ThreadType, MessageType, ChannelType } from '@dxos/plugin-space/types';
@@ -43,24 +41,15 @@ import {
   fullyQualifiedId,
   loadObjectReferences,
 } from '@dxos/react-client/echo';
-import { ScrollArea } from '@dxos/react-ui';
-import { createAttendableAttributes } from '@dxos/react-ui-attention';
 import { comments, createExternalCommentSync, listener } from '@dxos/react-ui-editor';
 import { translations as threadTranslations } from '@dxos/react-ui-thread';
 import { nonNullable } from '@dxos/util';
 
-import {
-  ThreadMain,
-  ThreadSettings,
-  CommentsContainer,
-  CommentsHeading,
-  ChatContainer,
-  ChatHeading,
-  ThreadArticle,
-} from './components';
+import { ThreadMain, ThreadSettings, ChatContainer, ChatHeading, ThreadArticle } from './components';
+import { ThreadComplementary } from './components/ThreadComplementary';
 import meta, { THREAD_ITEM, THREAD_PLUGIN } from './meta';
 import translations from './translations';
-import { ThreadAction, type ThreadProvides, type ThreadPluginProvides, type ThreadSettingsProps } from './types';
+import { ThreadAction, type ThreadPluginProvides, type ThreadSettingsProps } from './types';
 
 type ThreadState = {
   /** An in-memory staging area for threads that are being drafted. */
@@ -74,8 +63,6 @@ const initialViewState = { showResolvedThreads: false };
 type ViewStore = Record<SubjectId, typeof initialViewState>;
 
 // TODO(Zan): More robust runtime check.
-const providesThreadsConfig = (plugin: any): Plugin<ThreadProvides<any>> | undefined =>
-  'thread' in plugin.provides ? (plugin as Plugin<ThreadProvides<any>>) : undefined;
 
 // TODO(Zan): Every instance of `cursor` should be replaced with `anchor`.
 export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
@@ -93,7 +80,6 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
   let attentionPlugin: Plugin<AttentionPluginProvides> | undefined;
   let navigationPlugin: Plugin<LocationProvides> | undefined;
   let intentPlugin: Plugin<IntentPluginProvides> | undefined;
-  let dispatch: IntentDispatcher | undefined;
 
   const unsubscribeCallbacks = [] as UnsubscribeCallback[];
 
@@ -105,7 +91,6 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
       attentionPlugin = resolvePlugin(plugins, parseAttentionPlugin);
       navigationPlugin = resolvePlugin(plugins, parseNavigationPlugin);
       intentPlugin = resolvePlugin(plugins, parseIntentPlugin)!;
-      dispatch = intentPlugin?.provides.intent.dispatch;
 
       const graphPlugin = resolvePlugin(plugins, parseGraphPlugin);
       const client = resolvePlugin(plugins, parseClientPlugin)?.provides.client;
@@ -125,7 +110,10 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
 
         const firstAttendedNodeWithComments = Array.from(attention.attended)
           .map((id) => graphPlugin?.provides.graph.findNode(id))
-          .find((node) => node?.data instanceof DocumentType && (node.data.threads?.length ?? 0) > 0);
+          .find((node) => {
+            const data = node?.data as { threads?: unknown };
+            return Array.isArray(data?.threads) && data.threads.length > 0;
+          });
 
         if (firstAttendedNodeWithComments) {
           void intentPlugin?.provides.intent.dispatch({
@@ -211,7 +199,6 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                 const label = docMeta.label?.(doc) ||
                   doc.name ||
                   docMeta.placeholder || ['unnamed object threads label', { ns: THREAD_PLUGIN }];
-                // const label = docMeta.label?.(doc) || doc.name || docMeta.placeholder;
 
                 const viewState = getViewState(docId);
 
@@ -256,6 +243,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                       menuItemType: 'toggle',
                       isChecked: viewState.showResolvedThreads,
                       testId: 'threadPlugin.toggleShowResolved',
+                      iconSymbol: viewState.showResolvedThreads ? 'ph--eye-slash--regular' : 'ph--eye--regular',
                     },
                   },
                 ];
@@ -314,8 +302,6 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
             case 'article':
             case 'complementary': {
               const location = navigationPlugin?.provides.location;
-              const threadsIntegrators = useResolvePlugins(providesThreadsConfig);
-              const threadProvides = threadsIntegrators.map((p) => p.provides.thread);
 
               if (data.object instanceof ChannelType && data.object.threads[0]) {
                 const channel = data.object;
@@ -348,85 +334,17 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                 'threads' in data.subject &&
                 Array.isArray(data.subject.threads)
               ) {
-                const threads = data.subject.threads
-                  .concat(state.staging[fullyQualifiedId(data.subject)])
-                  .filter(nonNullable);
-
-                const createSort = threadProvides.find((p) => p.predicate(data.subject))?.createSort;
-                if (createSort) {
-                  const sort = createSort(data.subject);
-                  threads.sort((a, b) => sort(a.anchor, b.anchor));
-                }
-
-                const detached = data.subject.threads
-                  .filter(nonNullable)
-                  .filter(({ anchor }) => !anchor)
-                  .map((thread) => thread.id);
-
-                const qualifiedSubjectId = fullyQualifiedId(data.subject);
-                const attention = attentionPlugin?.provides.attention?.attended ?? new Set([qualifiedSubjectId]);
-                const attendableAttrs = createAttendableAttributes(qualifiedSubjectId);
-                const { showResolvedThreads } = getViewState(qualifiedSubjectId);
+                const { showResolvedThreads } = getViewState(fullyQualifiedId(data.subject));
 
                 return (
-                  <div role='none' className='contents group/attention' {...attendableAttrs}>
-                    {role === 'complementary' && <CommentsHeading attendableId={qualifiedSubjectId} />}
-                    <ScrollArea.Root classNames='row-span-2'>
-                      <ScrollArea.Viewport>
-                        <CommentsContainer
-                          threads={threads}
-                          detached={detached}
-                          currentId={attention.has(qualifiedSubjectId) ? state.current : undefined}
-                          autoFocusCurrentTextbox={state.focus}
-                          showResolvedThreads={showResolvedThreads}
-                          onThreadAttend={(thread) => {
-                            if (state.current !== thread.id) {
-                              state.current = thread.id;
-                              void dispatch?.({
-                                action: LayoutAction.SCROLL_INTO_VIEW,
-                                data: {
-                                  id: fullyQualifiedId(data.subject!),
-                                  thread: fullyQualifiedId(thread),
-                                  cursor: thread.anchor,
-                                },
-                              });
-                            }
-                          }}
-                          onThreadDelete={(thread) =>
-                            dispatch?.({
-                              plugin: THREAD_PLUGIN,
-                              action: ThreadAction.DELETE,
-                              data: { subject: data.subject, thread },
-                            })
-                          }
-                          onMessageDelete={(thread, messageId) =>
-                            dispatch?.({
-                              plugin: THREAD_PLUGIN,
-                              action: ThreadAction.DELETE_MESSAGE,
-                              data: { subject: data.subject, thread, messageId },
-                            })
-                          }
-                          onThreadToggleResolved={(thread) =>
-                            dispatch?.({
-                              plugin: THREAD_PLUGIN,
-                              action: ThreadAction.TOGGLE_RESOLVED,
-                              data: { thread },
-                            })
-                          }
-                          onComment={(thread) => {
-                            void intentPlugin?.provides.intent.dispatch({
-                              action: ThreadAction.ON_MESSAGE_ADD,
-                              data: { thread, subject: data.subject },
-                            });
-                          }}
-                        />
-                        <div role='none' className='bs-10' />
-                        <ScrollArea.Scrollbar>
-                          <ScrollArea.Thumb />
-                        </ScrollArea.Scrollbar>
-                      </ScrollArea.Viewport>
-                    </ScrollArea.Root>
-                  </div>
+                  <ThreadComplementary
+                    role={role}
+                    subject={data.subject}
+                    stagedThreads={state.staging[fullyQualifiedId(data.subject)]}
+                    current={state.current}
+                    focus
+                    showResolvedThreads={showResolvedThreads}
+                  />
                 );
               }
             }
@@ -442,6 +360,17 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
               if (intent.data && intent.data.cursor !== undefined) {
                 const { cursor, name, subject } = intent.data;
 
+                // Seed the threads array if it does not exist.
+                if (subject?.threads === undefined) {
+                  try {
+                    // Static schema will throw an error if subject does not support threads array property.
+                    subject.threads = [];
+                  } catch (e) {
+                    log.error('Subject does not support threads array', subject?.typename);
+                    return;
+                  }
+                }
+
                 const subjectId = fullyQualifiedId(subject);
                 const thread = create(ThreadType, { name, anchor: cursor, messages: [], status: 'staged' });
                 const stagingArea = state.staging[subjectId];
@@ -465,7 +394,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                       },
                       {
                         action: ThreadAction.SELECT,
-                        data: { current: thread.id, focus: true },
+                        data: { current: fullyQualifiedId(thread), focus: true },
                       },
                       {
                         action: LayoutAction.SET_LAYOUT,
@@ -519,7 +448,10 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
 
             case ThreadAction.DELETE: {
               const { subject, thread } = intent.data ?? {};
-              if (!(subject instanceof DocumentType) || !(thread instanceof ThreadType)) {
+              if (
+                !(thread instanceof ThreadType) ||
+                !(subject && typeof subject === 'object' && 'threads' in subject)
+              ) {
                 return;
               }
 
@@ -531,7 +463,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                 const index = stagingArea.findIndex((t) => t.id === thread.id);
                 if (index !== -1) {
                   stagingArea.splice(index, 1);
-                  return;
+                  return { data: true };
                 }
               }
 
@@ -541,7 +473,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
               }
 
               if (!intent.undo) {
-                const index = subject.threads.findIndex((t) => t?.id === thread.id);
+                const index = subject.threads.findIndex((t: any) => t?.id === thread.id);
                 const cursor = subject.threads[index]?.anchor;
                 if (index !== -1) {
                   subject.threads?.splice(index, 1);
@@ -587,7 +519,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
               const { thread, subject } = intent.data ?? {};
               if (
                 !(thread instanceof ThreadType) ||
-                !(subject && typeof subject === 'object' && 'threads' in subject)
+                !(subject && typeof subject === 'object' && 'threads' in subject && Array.isArray(subject.threads))
               ) {
                 return;
               }
@@ -627,7 +559,10 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
               const { subject, thread, messageId } = intent.data ?? {};
               const space = getSpace(subject);
 
-              if (!(subject instanceof DocumentType) || !(thread instanceof ThreadType) || !space) {
+              if (
+                !(thread instanceof ThreadType) ||
+                !(subject && typeof subject === 'object' && 'threads' in subject)
+              ) {
                 return;
               }
 
@@ -658,7 +593,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                         action: ObservabilityAction.SEND_EVENT,
                         data: {
                           name: 'threads.message.delete',
-                          properties: { threadId: thread.id, spaceId: space.id },
+                          properties: { threadId: thread.id, spaceId: space?.id },
                         },
                       },
                     ],
@@ -682,7 +617,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                         action: ObservabilityAction.SEND_EVENT,
                         data: {
                           name: 'threads.message.undo-delete',
-                          properties: { threadId: thread.id, spaceId: space.id },
+                          properties: { threadId: thread.id, spaceId: space?.id },
                         },
                       },
                     ],
@@ -733,7 +668,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
               () =>
                 threads.value
                   .filter((thread) => thread?.anchor)
-                  .map((thread) => ({ id: thread.id, cursor: thread.anchor! })),
+                  .map((thread) => ({ id: fullyQualifiedId(thread), cursor: thread.anchor! })),
             ),
             comments({
               id: doc.id,
@@ -754,7 +689,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                 // If the thread is in the staging area, remove it.
                 const stagingArea = state.staging[fullyQualifiedId(doc)];
                 if (stagingArea) {
-                  const index = stagingArea.findIndex((thread) => thread.id === id);
+                  const index = stagingArea.findIndex((thread) => fullyQualifiedId(thread) === id);
                   if (index !== -1) {
                     stagingArea.splice(index, 1);
                   }
@@ -767,7 +702,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
               },
               onUpdate: ({ id, cursor }) => {
                 const thread =
-                  state.staging[fullyQualifiedId(doc)]?.find((thread) => thread.id === id) ??
+                  state.staging[fullyQualifiedId(doc)]?.find((thread) => fullyQualifiedId(thread) === id) ??
                   doc.threads.find((thread) => thread?.id === id);
 
                 if (thread instanceof ThreadType && thread.anchor) {

package/src/components/ChatContainer.tsx

@@ -7,7 +7,7 @@ import React, { useLayoutEffect, useMemo, useRef, useState } from 'react';
 
 import { create } from '@dxos/echo-schema';
 import { MessageType } from '@dxos/plugin-space/types';
-import { getSpace, useMembers } from '@dxos/react-client/echo';
+import { fullyQualifiedId, getSpace, useMembers } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { ScrollArea, useThemeContext, useTranslation } from '@dxos/react-ui';
 import { PlankHeading, plankHeadingIconProps } from '@dxos/react-ui-deck';
@@ -39,7 +39,7 @@ export const ChatContainer = ({ thread, context, current, autoFocusTextbox }: Th
   const identity = useIdentity()!;
   const space = getSpace(thread);
   const members = useMembers(space?.key);
-  const activity = useStatus(space, thread.id);
+  const activity = useStatus(space, fullyQualifiedId(thread));
   const { t } = useTranslation(THREAD_PLUGIN);
   // TODO(wittjosiah): This is a hack to reset the editor after a message is sent.
   const [_count, _setCount] = useState(0);
@@ -48,7 +48,7 @@ export const ChatContainer = ({ thread, context, current, autoFocusTextbox }: Th
   const threadScrollRef = useRef<HTMLDivElement | null>(null);
   const { themeMode } = useThemeContext();
 
-  const textboxMetadata = getMessageMetadata(thread.id, identity);
+  const textboxMetadata = getMessageMetadata(fullyQualifiedId(thread), identity);
   const messageRef = useRef('');
   const extensions = useMemo(
     () => [
@@ -103,7 +103,7 @@ export const ChatContainer = ({ thread, context, current, autoFocusTextbox }: Th
   return (
     <Thread
       current={current}
-      id={thread.id}
+      id={fullyQualifiedId(thread)}
       classNames='bs-full grid-rows-[1fr_min-content_min-content] overflow-hidden transition-[padding-block-end] [[data-sidebar-inline-start-state=open]_&]:lg:pbe-0'
     >
       <ScrollArea.Root classNames='col-span-2'>

package/src/components/CommentContainer.tsx

@@ -7,7 +7,7 @@ import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 
 import { create } from '@dxos/echo-schema';
 import { MessageType } from '@dxos/plugin-space/types';
-import { getSpace, useMembers } from '@dxos/react-client/echo';
+import { fullyQualifiedId, getSpace, useMembers } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { Button, Tag, Tooltip, useThemeContext, useTranslation } from '@dxos/react-ui';
 import { createBasicExtensions, createThemeExtensions, listener } from '@dxos/react-ui-editor';
@@ -103,13 +103,13 @@ export const CommentContainer = ({
   const identity = useIdentity()!;
   const space = getSpace(thread);
   const members = useMembers(space?.key);
-  const activity = useStatus(space, thread.id);
+  const activity = useStatus(space, fullyQualifiedId(thread));
   const { t } = useTranslation(THREAD_PLUGIN);
   const threadScrollRef = useRef<HTMLDivElement | null>(null);
   const [autoFocus, setAutoFocus] = useState(!!autoFocusTextbox);
   const { themeMode } = useThemeContext();
 
-  const textboxMetadata = getMessageMetadata(thread.id, identity);
+  const textboxMetadata = getMessageMetadata(fullyQualifiedId(thread), identity);
   // TODO(wittjosiah): This is a hack to reset the editor after a message is sent.
   const [_count, _setCount] = useState(0);
   const rerenderEditor = () => _setCount((count) => count + 1);
@@ -159,10 +159,8 @@ export const CommentContainer = ({
     return true;
   }, [thread, identity]);
 
-  const handleDeleteMessage = (id: string) => onMessageDelete?.(id);
-
   return (
-    <Thread onClickCapture={onAttend} onFocusCapture={onAttend} current={current} id={thread.id}>
+    <Thread onClickCapture={onAttend} onFocusCapture={onAttend} current={current} id={fullyQualifiedId(thread)}>
       <div
         role='none'
         className={mx(
@@ -195,7 +193,12 @@ export const CommentContainer = ({
         </div>
       </div>
       {thread.messages.filter(nonNullable).map((message) => (
-        <MessageContainer key={message.id} message={message} members={members} onDelete={handleDeleteMessage} />
+        <MessageContainer
+          key={message.id}
+          message={message}
+          members={members}
+          onDelete={(id: string) => onMessageDelete?.(id)}
+        />
       ))}
       <MessageTextbox extensions={extensions} autoFocus={autoFocus} onSend={handleCreate} {...textboxMetadata} />
       <ThreadFooter activity={activity}>{t('activity message')}</ThreadFooter>

package/src/components/Comments.stories.tsx

@@ -8,7 +8,7 @@ import React, { useEffect, useState } from 'react';
 
 import { MessageType, ThreadType } from '@dxos/plugin-space/types';
 import { faker } from '@dxos/random';
-import { Filter, useQuery, useSpace } from '@dxos/react-client/echo';
+import { Filter, fullyQualifiedId, useQuery, useSpace } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { type ClientRepeatedComponentProps, ClientRepeater } from '@dxos/react-client/testing';
 import { withLayout, withTheme } from '@dxos/storybook-utils';
@@ -30,7 +30,7 @@ const Story = ({ spaceKey }: ClientRepeatedComponentProps) => {
       const t = setTimeout(async () => {
         space.db.add(createCommentThread(identity));
         const thread = space.db.add(createCommentThread(identity));
-        setDetached([thread.id]);
+        setDetached([fullyQualifiedId(thread)]);
       });
 
       return () => clearTimeout(t);

package/src/components/CommentsContainer.tsx

@@ -6,6 +6,7 @@ import { ChatText, Quotes } from '@phosphor-icons/react';
 import React, { useEffect } from 'react';
 
 import { type ThreadType } from '@dxos/plugin-space/types';
+import { fullyQualifiedId } from '@dxos/react-client/echo';
 import { useTranslation, Trans } from '@dxos/react-ui';
 import { PlankHeading, plankHeadingIconProps } from '@dxos/react-ui-deck';
 import { descriptionText, mx } from '@dxos/react-ui-theme';
@@ -73,20 +74,23 @@ export const CommentsContainer = ({
   return (
     <>
       {filteredThreads.length > 0 ? (
-        filteredThreads.map((thread) => (
-          <CommentContainer
-            key={thread.id}
-            thread={thread}
-            current={currentId === thread.id}
-            detached={detached.includes(thread.id)}
-            autoFocusTextbox={autoFocusCurrentTextbox && currentId === thread.id}
-            {...(onThreadAttend && { onAttend: () => onThreadAttend(thread) })}
-            {...(onThreadDelete && { onThreadDelete: () => onThreadDelete(thread) })}
-            {...(onMessageDelete && { onMessageDelete: (messageId: string) => onMessageDelete(thread, messageId) })}
-            {...(onThreadToggleResolved && { onResolve: () => onThreadToggleResolved(thread) })}
-            {...props}
-          />
-        ))
+        filteredThreads.map((thread) => {
+          const threadId = fullyQualifiedId(thread);
+          return (
+            <CommentContainer
+              key={threadId}
+              thread={thread}
+              current={currentId === threadId}
+              detached={detached.includes(threadId)}
+              autoFocusTextbox={autoFocusCurrentTextbox && currentId === threadId}
+              {...(onThreadAttend && { onAttend: () => onThreadAttend(thread) })}
+              {...(onThreadDelete && { onThreadDelete: () => onThreadDelete(thread) })}
+              {...(onMessageDelete && { onMessageDelete: (messageId: string) => onMessageDelete(thread, messageId) })}
+              {...(onThreadToggleResolved && { onResolve: () => onThreadToggleResolved(thread) })}
+              {...props}
+            />
+          );
+        })
       ) : (
         <div
           role='alert'

package/src/components/MessageContainer.tsx

@@ -1,6 +1,7 @@
 //
 // Copyright 2024 DXOS.org
 //
+
 import { EditorView } from '@codemirror/view';
 import { Check, PencilSimple, X } from '@phosphor-icons/react';
 import React, { forwardRef, useCallback, useEffect, useRef, useState } from 'react';
@@ -91,7 +92,7 @@ export const MessageContainer = ({
                   variant='ghost'
                   data-testid='thread.message.delete'
                   classNames={messageControlClassNames}
-                  onClick={handleDelete}
+                  onClick={() => handleDelete()}
                 >
                   <span className='sr-only'>{deleteLabel}</span>
                   <X className={getSize(4)} />

package/src/components/ThreadComplementary.tsx

@@ -0,0 +1,120 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { useEffect, useMemo } from 'react';
+
+import { LayoutAction, type Plugin, useIntentDispatcher, useResolvePlugins } from '@dxos/app-framework';
+import { type ThreadType } from '@dxos/plugin-space';
+import { fullyQualifiedId } from '@dxos/react-client/echo';
+import { ScrollArea } from '@dxos/react-ui';
+import { createAttendableAttributes, useAttentionContext } from '@dxos/react-ui-attention';
+import { nonNullable } from '@dxos/util';
+
+import { CommentsContainer, CommentsHeading } from '../components';
+import { THREAD_PLUGIN } from '../meta';
+import { ThreadAction, type ThreadProvides } from '../types';
+
+const providesThreadsConfig = (plugin: any): Plugin<ThreadProvides<any>> | undefined =>
+  'thread' in plugin.provides ? (plugin as Plugin<ThreadProvides<any>>) : undefined;
+
+export const ThreadComplementary = ({
+  role,
+  subject,
+  stagedThreads,
+  current,
+  focus,
+  showResolvedThreads,
+}: {
+  role: string;
+  subject: any;
+  stagedThreads: ThreadType[] | undefined;
+  current?: string;
+  focus?: boolean;
+  showResolvedThreads?: boolean;
+}) => {
+  const dispatch = useIntentDispatcher();
+
+  const threadsIntegrators = useResolvePlugins(providesThreadsConfig);
+  const threadProvides = useMemo(() => threadsIntegrators.map((p) => p.provides.thread), [threadsIntegrators]);
+  const createSort = useMemo(
+    () => threadProvides.find((p) => p.predicate(subject))?.createSort,
+    [threadProvides, subject],
+  );
+  const sort = useMemo(() => createSort?.(subject), [createSort, subject]);
+
+  const threads = useMemo(() => {
+    return subject.threads.concat(stagedThreads ?? []).filter(nonNullable) as ThreadType[];
+  }, [JSON.stringify(subject.threads), JSON.stringify(stagedThreads)]);
+
+  const detachedIds = useMemo(() => {
+    return threads.filter(({ anchor }) => !anchor).map((thread) => fullyQualifiedId(thread));
+  }, [threads]);
+
+  useEffect(() => {
+    if (!sort) {
+      return;
+    }
+    threads.sort((a, b) => sort(a?.anchor, b?.anchor));
+  }, [sort, threads]);
+
+  // TODO(Zan): Maybe we should have a hook for this?
+  const { attended } = useAttentionContext('Thread Complementary');
+  const qualifiedSubjectId = fullyQualifiedId(subject);
+
+  const attendableAttrs = createAttendableAttributes(qualifiedSubjectId);
+
+  return (
+    <div role='none' className='contents group/attention' {...attendableAttrs}>
+      {role === 'complementary' && <CommentsHeading attendableId={qualifiedSubjectId} />}
+      <ScrollArea.Root classNames='row-span-2'>
+        <ScrollArea.Viewport>
+          <CommentsContainer
+            threads={threads}
+            detached={detachedIds}
+            currentId={attended.has(qualifiedSubjectId) ? current : undefined}
+            autoFocusCurrentTextbox={focus}
+            showResolvedThreads={showResolvedThreads}
+            onThreadAttend={(thread) => {
+              const threadId = fullyQualifiedId(thread);
+              if (current !== threadId) {
+                current = threadId;
+
+                void dispatch?.([
+                  {
+                    action: LayoutAction.SCROLL_INTO_VIEW,
+                    data: {
+                      id: fullyQualifiedId(subject),
+                      thread: threadId,
+                      cursor: thread.anchor,
+                    },
+                  },
+                ]);
+              }
+            }}
+            onThreadDelete={(thread) => {
+              return dispatch({ plugin: THREAD_PLUGIN, action: ThreadAction.DELETE, data: { subject, thread } });
+            }}
+            onMessageDelete={(thread, messageId) =>
+              dispatch({
+                plugin: THREAD_PLUGIN,
+                action: ThreadAction.DELETE_MESSAGE,
+                data: { subject, thread, messageId },
+              })
+            }
+            onThreadToggleResolved={(thread) =>
+              dispatch({ plugin: THREAD_PLUGIN, action: ThreadAction.TOGGLE_RESOLVED, data: { thread } })
+            }
+            onComment={(thread) => {
+              void dispatch({ action: ThreadAction.ON_MESSAGE_ADD, data: { thread, subject } });
+            }}
+          />
+          <div role='none' className='bs-10' />
+          <ScrollArea.Scrollbar>
+            <ScrollArea.Thumb />
+          </ScrollArea.Scrollbar>
+        </ScrollArea.Viewport>
+      </ScrollArea.Root>
+    </div>
+  );
+};

package/src/types.ts

@@ -31,7 +31,7 @@ export enum ThreadAction {
 export type ThreadProvides<T> = {
   thread: {
     predicate: (obj: any) => obj is T;
-    createSort: (obj: T) => (anchorA: string, anchorB: string) => number;
+    createSort: (obj: T) => (anchorA: string | undefined, anchorB: string | undefined) => number;
   };
 };