@dxos/plugin-thread 0.6.12-staging.e11e696 → 0.6.12

package/src/ThreadPlugin.tsx

@@ -2,6 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Chat, type IconProps } from '@phosphor-icons/react';
 import { computed, effect } from '@preact/signals-core';
 import React from 'react';
 
@@ -15,40 +16,57 @@ import {
   parseIntentPlugin,
   parseNavigationPlugin,
   resolvePlugin,
+  parseGraphPlugin,
+  SLUG_PATH_SEPARATOR,
+  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, toSignal } from '@dxos/plugin-graph';
+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';
 import {
   getSpace,
   getTextInRange,
+  Filter,
   createDocAccessor,
   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, ChatContainer, ChatHeading, ThreadArticle } from './components';
-import { ThreadComplementary } from './components/ThreadComplementary';
+import {
+  ThreadMain,
+  ThreadSettings,
+  CommentsContainer,
+  CommentsHeading,
+  ChatContainer,
+  ChatHeading,
+  ThreadArticle,
+} from './components';
 import meta, { THREAD_ITEM, THREAD_PLUGIN } from './meta';
 import translations from './translations';
-import { ThreadAction, type ThreadPluginProvides, type ThreadSettingsProps } from './types';
+import { ThreadAction, type ThreadProvides, type ThreadPluginProvides, type ThreadSettingsProps } from './types';
 
 type ThreadState = {
   /** An in-memory staging area for threads that are being drafted. */
   staging: Record<string, ThreadType[]>;
   current?: string | undefined;
+  focus?: boolean;
 };
 
 type SubjectId = string;
@@ -56,6 +74,8 @@ 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> => {
@@ -70,8 +90,10 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
     return viewStore[subjectId];
   };
 
+  let attentionPlugin: Plugin<AttentionPluginProvides> | undefined;
   let navigationPlugin: Plugin<LocationProvides> | undefined;
   let intentPlugin: Plugin<IntentPluginProvides> | undefined;
+  let dispatch: IntentDispatcher | undefined;
 
   const unsubscribeCallbacks = [] as UnsubscribeCallback[];
 
@@ -80,8 +102,45 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
     ready: async (plugins) => {
       settings.prop({ key: 'standalone', type: LocalStorageStore.bool({ allowUndefined: true }) });
 
+      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;
+      if (!client) {
+        return;
+      }
+
+      // TODO(wittjosiah): This is a hack to make standalone threads work in the c11y sidebar.
+      //  This should have a better solution when deck is introduced.
+      const channelsQuery = client.spaces.query(Filter.schema(ChannelType));
+      const queryUnsubscribe = channelsQuery.subscribe();
+      const unsubscribe = effect(() => {
+        const attention = attentionPlugin?.provides.attention;
+        if (!attention?.attended) {
+          return;
+        }
+
+        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);
+
+        if (firstAttendedNodeWithComments) {
+          void intentPlugin?.provides.intent.dispatch({
+            action: NavigationAction.OPEN,
+            data: {
+              activeParts: {
+                complementary: `${firstAttendedNodeWithComments.id}${SLUG_PATH_SEPARATOR}comments`,
+              },
+            },
+          });
+        }
+      });
+
+      unsubscribeCallbacks.push(queryUnsubscribe);
+      unsubscribeCallbacks.push(unsubscribe);
     },
     unload: async () => {
       unsubscribeCallbacks.forEach((unsubscribe) => unsubscribe());
@@ -92,7 +151,8 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
         records: {
           [ChannelType.typename]: {
             placeholder: ['channel title placeholder', { ns: THREAD_PLUGIN }],
-            icon: 'ph--chat--regular',
+            icon: (props: IconProps) => <Chat {...props} />,
+            iconSymbol: 'ph--chat--regular',
             // TODO(wittjosiah): Move out of metadata.
             loadReferences: (channel: ChannelType) => loadObjectReferences(channel, (channel) => channel.threads),
           },
@@ -138,42 +198,31 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                   return;
                 }
 
-                // TODO(Zan): Find util (or make one).
-                const subjectId = id.split('~').at(0);
-                const [spaceId, objectId] = subjectId?.split(':') ?? [];
+                // TODO(Zan): Find util (or make one)
+                const docId = id.split('~').at(0);
+                const [spaceId, objectId] = docId?.split(':') ?? [];
                 const space = client.spaces.get().find((space) => space.id === spaceId);
-                const object = toSignal(
-                  (onChange) => {
-                    const timeout = setTimeout(async () => {
-                      await space?.db.loadObjectById(objectId);
-                      onChange();
-                    });
-
-                    return () => clearTimeout(timeout);
-                  },
-                  () => space?.db.getObjectById(objectId),
-                  subjectId,
-                );
-                if (!object || !subjectId) {
+                const doc = space?.db.getObjectById(objectId);
+                if (!doc || !docId) {
                   return;
                 }
 
-                const meta = metadataResolver(getTypename(object) ?? '');
-                const label = meta.label?.(object) ||
-                  object.name ||
-                  meta.placeholder || ['unnamed object threads label', { ns: THREAD_PLUGIN }];
+                const docMeta = metadataResolver(getTypename(doc) ?? '');
+                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(subjectId);
+                const viewState = getViewState(docId);
 
                 return {
                   id,
                   type: 'orphan-comments-for-subject',
-                  data: null,
+                  data: doc,
                   properties: {
-                    icon: 'ph--chat-text--regular',
+                    icon: meta.iconComponent,
                     label,
                     showResolvedThreads: viewState.showResolvedThreads,
-                    object,
                   },
                 };
               },
@@ -207,7 +256,6 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                       menuItemType: 'toggle',
                       isChecked: viewState.showResolvedThreads,
                       testId: 'threadPlugin.toggleShowResolved',
-                      icon: viewState.showResolvedThreads ? 'ph--eye-slash--regular' : 'ph--eye--regular',
                     },
                   },
                 ];
@@ -239,7 +287,8 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                     },
                     properties: {
                       label: ['create channel label', { ns: THREAD_PLUGIN }],
-                      icon: 'ph--chat--regular',
+                      icon: (props: IconProps) => <Chat {...props} />,
+                      iconSymbol: 'ph--chat--regular',
                       testId: 'threadPlugin.createObject',
                     },
                   },
@@ -265,6 +314,8 @@ 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;
@@ -297,16 +348,85 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                 'threads' in data.subject &&
                 Array.isArray(data.subject.threads)
               ) {
-                const { showResolvedThreads } = getViewState(fullyQualifiedId(data.subject));
+                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);
 
                 return (
-                  <ThreadComplementary
-                    role={role}
-                    subject={data.subject}
-                    stagedThreads={state.staging[fullyQualifiedId(data.subject)]}
-                    current={state.current}
-                    showResolvedThreads={showResolvedThreads}
-                  />
+                  <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>
                 );
               }
             }
@@ -322,17 +442,6 @@ 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];
@@ -346,9 +455,17 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                   data: thread,
                   intents: [
                     [
+                      {
+                        action: NavigationAction.OPEN,
+                        data: {
+                          activeParts: {
+                            complementary: `${subjectId}${SLUG_PATH_SEPARATOR}comments${SLUG_COLLECTION_INDICATOR}`,
+                          },
+                        },
+                      },
                       {
                         action: ThreadAction.SELECT,
-                        data: { current: fullyQualifiedId(thread) },
+                        data: { current: thread.id, focus: true },
                       },
                       {
                         action: LayoutAction.SET_LAYOUT,
@@ -368,6 +485,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
             }
 
             case ThreadAction.SELECT: {
+              state.focus = intent.data?.current === state.current ? state.focus : intent.data?.focus;
               state.current = intent.data?.current;
               return { data: true };
             }
@@ -401,10 +519,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
 
             case ThreadAction.DELETE: {
               const { subject, thread } = intent.data ?? {};
-              if (
-                !(thread instanceof ThreadType) ||
-                !(subject && typeof subject === 'object' && 'threads' in subject)
-              ) {
+              if (!(subject instanceof DocumentType) || !(thread instanceof ThreadType)) {
                 return;
               }
 
@@ -416,7 +531,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
                 const index = stagingArea.findIndex((t) => t.id === thread.id);
                 if (index !== -1) {
                   stagingArea.splice(index, 1);
-                  return { data: true };
+                  return;
                 }
               }
 
@@ -426,7 +541,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
               }
 
               if (!intent.undo) {
-                const index = subject.threads.findIndex((t: any) => t?.id === thread.id);
+                const index = subject.threads.findIndex((t) => t?.id === thread.id);
                 const cursor = subject.threads[index]?.anchor;
                 if (index !== -1) {
                   subject.threads?.splice(index, 1);
@@ -472,7 +587,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
               const { thread, subject } = intent.data ?? {};
               if (
                 !(thread instanceof ThreadType) ||
-                !(subject && typeof subject === 'object' && 'threads' in subject && Array.isArray(subject.threads))
+                !(subject && typeof subject === 'object' && 'threads' in subject)
               ) {
                 return;
               }
@@ -512,10 +627,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
               const { subject, thread, messageId } = intent.data ?? {};
               const space = getSpace(subject);
 
-              if (
-                !(thread instanceof ThreadType) ||
-                !(subject && typeof subject === 'object' && 'threads' in subject)
-              ) {
+              if (!(subject instanceof DocumentType) || !(thread instanceof ThreadType) || !space) {
                 return;
               }
 
@@ -546,7 +658,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 },
                         },
                       },
                     ],
@@ -570,7 +682,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 },
                         },
                       },
                     ],
@@ -616,15 +728,15 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
               },
             }),
             createExternalCommentSync(
-              fullyQualifiedId(doc),
+              doc.id,
               (sink) => effect(() => sink()),
               () =>
                 threads.value
                   .filter((thread) => thread?.anchor)
-                  .map((thread) => ({ id: fullyQualifiedId(thread), cursor: thread.anchor! })),
+                  .map((thread) => ({ id: thread.id, cursor: thread.anchor! })),
             ),
             comments({
-              id: fullyQualifiedId(doc),
+              id: doc.id,
               onCreate: ({ cursor }) => {
                 const [start, end] = cursor.split(':');
                 const name = doc.content && getTextInRange(createDocAccessor(doc.content, ['content']), start, end);
@@ -642,7 +754,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) => fullyQualifiedId(thread) === id);
+                  const index = stagingArea.findIndex((thread) => thread.id === id);
                   if (index !== -1) {
                     stagingArea.splice(index, 1);
                   }
@@ -655,7 +767,7 @@ export const ThreadPlugin = (): PluginDefinition<ThreadPluginProvides> => {
               },
               onUpdate: ({ id, cursor }) => {
                 const thread =
-                  state.staging[fullyQualifiedId(doc)]?.find((thread) => fullyQualifiedId(thread) === id) ??
+                  state.staging[fullyQualifiedId(doc)]?.find((thread) => thread.id === id) ??
                   doc.threads.find((thread) => thread?.id === id);
 
                 if (thread instanceof ThreadType && thread.anchor) {

package/src/components/ChatContainer.tsx

@@ -2,14 +2,15 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Chat } from '@phosphor-icons/react';
 import React, { useLayoutEffect, useMemo, useRef, useState } from 'react';
 
 import { create } from '@dxos/echo-schema';
 import { MessageType } from '@dxos/plugin-space/types';
-import { fullyQualifiedId, getSpace, useMembers } from '@dxos/react-client/echo';
+import { getSpace, useMembers } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
-import { Icon, ScrollArea, useThemeContext, useTranslation } from '@dxos/react-ui';
-import { PlankHeading } from '@dxos/react-ui-deck';
+import { ScrollArea, useThemeContext, useTranslation } from '@dxos/react-ui';
+import { PlankHeading, plankHeadingIconProps } from '@dxos/react-ui-deck';
 import { createBasicExtensions, createThemeExtensions, listener } from '@dxos/react-ui-editor';
 import { mx } from '@dxos/react-ui-theme';
 import { MessageTextbox, type MessageTextboxProps, Thread, ThreadFooter, threadLayout } from '@dxos/react-ui-thread';
@@ -27,7 +28,7 @@ export const ChatHeading = ({ attendableId }: { attendableId?: string }) => {
   return (
     <div role='none' className='flex items-center'>
       <PlankHeading.Button attendableId={attendableId}>
-        <Icon icon='ph--chat--regular' size={5} />
+        <Chat {...plankHeadingIconProps} />
       </PlankHeading.Button>
       <PlankHeading.Label attendableId={attendableId}>{t('chat heading')}</PlankHeading.Label>
     </div>
@@ -38,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, fullyQualifiedId(thread));
+  const activity = useStatus(space, thread.id);
   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);
@@ -47,7 +48,7 @@ export const ChatContainer = ({ thread, context, current, autoFocusTextbox }: Th
   const threadScrollRef = useRef<HTMLDivElement | null>(null);
   const { themeMode } = useThemeContext();
 
-  const textboxMetadata = getMessageMetadata(fullyQualifiedId(thread), identity);
+  const textboxMetadata = getMessageMetadata(thread.id, identity);
   const messageRef = useRef('');
   const extensions = useMemo(
     () => [
@@ -102,7 +103,7 @@ export const ChatContainer = ({ thread, context, current, autoFocusTextbox }: Th
   return (
     <Thread
       current={current}
-      id={fullyQualifiedId(thread)}
+      id={thread.id}
       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

@@ -3,11 +3,11 @@
 //
 
 import { CheckCircle, X } from '@phosphor-icons/react';
-import React, { useCallback, useMemo, useRef, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
 import { create } from '@dxos/echo-schema';
 import { MessageType } from '@dxos/plugin-space/types';
-import { fullyQualifiedId, getSpace, useMembers } from '@dxos/react-client/echo';
+import { 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';
@@ -93,6 +93,7 @@ export const CommentContainer = ({
   detached,
   context,
   current,
+  autoFocusTextbox,
   onAttend,
   onThreadDelete,
   onMessageDelete,
@@ -102,12 +103,13 @@ export const CommentContainer = ({
   const identity = useIdentity()!;
   const space = getSpace(thread);
   const members = useMembers(space?.key);
-  const activity = useStatus(space, fullyQualifiedId(thread));
+  const activity = useStatus(space, thread.id);
   const { t } = useTranslation(THREAD_PLUGIN);
   const threadScrollRef = useRef<HTMLDivElement | null>(null);
+  const [autoFocus, setAutoFocus] = useState(!!autoFocusTextbox);
   const { themeMode } = useThemeContext();
 
-  const textboxMetadata = getMessageMetadata(fullyQualifiedId(thread), identity);
+  const textboxMetadata = getMessageMetadata(thread.id, 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);
@@ -122,6 +124,13 @@ export const CommentContainer = ({
     [_count],
   );
 
+  // TODO(thure): Because of the way the `autoFocus` property is handled by TextEditor,
+  //  this is the least-bad way of moving focus at the right time, though it is an anti-pattern.
+  //  Refactor to behave more like <input/>’s `autoFocus` or `autofocus` (yes, they’re different).
+  useEffect(() => {
+    setAutoFocus(!!autoFocusTextbox);
+  }, [autoFocusTextbox]);
+
   // TODO(thure): Factor out.
   const scrollToEnd = (behavior: ScrollBehavior) =>
     setTimeout(() => threadScrollRef.current?.scrollIntoView({ behavior, block: 'end' }), 10);
@@ -142,6 +151,7 @@ export const CommentContainer = ({
     onComment?.(thread);
 
     messageRef.current = '';
+    setAutoFocus(true);
     scrollToEnd('instant');
     rerenderEditor();
 
@@ -149,8 +159,10 @@ export const CommentContainer = ({
     return true;
   }, [thread, identity]);
 
+  const handleDeleteMessage = (id: string) => onMessageDelete?.(id);
+
   return (
-    <Thread onClickCapture={onAttend} onFocusCapture={onAttend} current={current} id={fullyQualifiedId(thread)}>
+    <Thread onClickCapture={onAttend} onFocusCapture={onAttend} current={current} id={thread.id}>
       <div
         role='none'
         className={mx(
@@ -183,20 +195,9 @@ export const CommentContainer = ({
         </div>
       </div>
       {thread.messages.filter(nonNullable).map((message) => (
-        <MessageContainer
-          key={message.id}
-          message={message}
-          members={members}
-          onDelete={(id: string) => onMessageDelete?.(id)}
-        />
+        <MessageContainer key={message.id} message={message} members={members} onDelete={handleDeleteMessage} />
       ))}
-      {/*
-        TODO(wittjosiah): Can't autofocus this generally.
-          There can be multiple threads with inputs and they can't all be focused.
-          Also, it steals focus from documents when first rendered.
-          Need to find a way to autofocus in one scenario only: when a new thread is created.
-      */}
-      <MessageTextbox extensions={extensions} onSend={handleCreate} {...textboxMetadata} />
+      <MessageTextbox extensions={extensions} autoFocus={autoFocus} onSend={handleCreate} {...textboxMetadata} />
       <ThreadFooter activity={activity}>{t('activity message')}</ThreadFooter>
       {/* NOTE(thure): This can’t also be the `overflow-anchor` because `ScrollArea` injects an interceding node that contains this necessary ref’d element. */}
       <div role='none' className='bs-px -mbs-px' ref={threadScrollRef} />

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, fullyQualifiedId, useQuery, useSpace } from '@dxos/react-client/echo';
+import { Filter, 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([fullyQualifiedId(thread)]);
+        setDetached([thread.id]);
       });
 
       return () => clearTimeout(t);