@dxos/plugin-thread 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

package/src/capabilities/app-graph-builder.ts

@@ -2,180 +2,50 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
-import { Option, pipe } from 'effect';
-
-import { Capabilities, type PluginContext, 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';
-
-import { THREAD_PLUGIN, meta } from '../meta';
-import { ChannelType, ThreadAction } from '../types';
-import { getAnchor } from '../util';
-
-import { ThreadCapabilities } from './capabilities';
-
-export default (context: PluginContext) => {
-  const resolve = (typename: string) =>
-    context.getCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
-
-  return contributes(Capabilities.AppGraphBuilder, [
-    createExtension({
-      id: `${THREAD_PLUGIN}/active-call`,
-      connector: (node) =>
-        Rx.make((get) =>
-          pipe(
-            get(node),
-            Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
-            Option.map((node) => {
-              const [call] = get(context.capabilities(ThreadCapabilities.CallManager));
-              return get(
-                rxFromSignal(() =>
-                  call?.joined
-                    ? [
-                        {
-                          id: `${node.id}${ATTENDABLE_PATH_SEPARATOR}active-call`,
-                          type: DECK_COMPANION_TYPE,
-                          data: null,
-                          properties: {
-                            label: ['call panel label', { ns: THREAD_PLUGIN }],
-                            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: `${THREAD_PLUGIN}/channel-chat-companion`,
-      connector: (node) => {
-        return Rx.make((get) => {
-          return pipe(
-            get(node),
-            Option.flatMap((node) => (Obj.instanceOf(ChannelType, node.data) ? Option.some(node.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: THREAD_PLUGIN }],
-                    icon: 'ph--hash--regular',
-                    position: 'hoist',
-                    disposition: 'hidden',
-                  },
-                },
-              ];
-            }),
-            Option.getOrElse(() => []),
-          );
-        });
-      },
-    }),
-    createExtension({
-      id: `${meta.id}/comments-companion`,
-      connector: (node) =>
-        Rx.make((get) =>
-          pipe(
-            get(node),
-            Option.flatMap((node) => {
-              if (!Obj.isObject(node.data) || Obj.instanceOf(ChannelType, node.data)) {
-                return Option.none();
-              }
-              const metadata = resolve(Obj.getTypename(node.data)!);
-              return typeof metadata.comments === 'string' ? Option.some(node) : Option.none();
-            }),
-            Option.map((node) => [
-              {
-                id: [node.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',
-                },
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities, createTypeSectionExtension } from '@dxos/app-toolkit';
+import { isSpace } from '@dxos/client/echo';
+import { Operation } from '@dxos/compute';
+import { Type } from '@dxos/echo';
+import { GraphBuilder, Node } from '@dxos/plugin-graph';
+import { SpaceOperation } from '@dxos/plugin-space';
+import { Channel } from '@dxos/types';
+
+const channelTypename = Type.getTypename(Channel.Channel);
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const extensions = yield* Effect.all([
+      createTypeSectionExtension(Channel.Channel),
+
+      GraphBuilder.createExtension({
+        id: 'channelsSectionActions',
+        match: (node) => {
+          const space = isSpace(node.properties.space) ? node.properties.space : undefined;
+          return node.type === channelTypename && space ? Option.some(space) : Option.none();
+        },
+        actions: (space) =>
+          Effect.succeed([
+            Node.makeAction({
+              id: 'create-channel',
+              data: () =>
+                Operation.invoke(SpaceOperation.OpenCreateObject, {
+                  target: space.db,
+                  typename: channelTypename,
+                }),
+              properties: {
+                label: ['add-object.label', { ns: channelTypename }],
+                icon: 'ph--plus--regular',
+                disposition: 'list-item-primary',
               },
-            ]),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-    createExtension({
-      id: `${meta.id}/comment-toolbar`,
-      actions: (node) =>
-        Rx.make((get) =>
-          pipe(
-            get(node),
-            Option.flatMap((node) => {
-              if (!Obj.isObject(node.data) || Obj.instanceOf(ChannelType, node.data)) {
-                return Option.none();
-              }
-              const metadata = resolve(Obj.getTypename(node.data)!);
-              return typeof metadata.comments === 'string' ? Option.some(node.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));
-                    // TODO(wittjosiah): Use presence of selection to determine if the comment should be anchored.
-                    // Requires all components which support selection (e.g. table/kanban) to support anchored comments.
-                    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(() => []),
-          ),
-        ),
-    }),
-  ]);
-};
+    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
+  }),
+);

package/src/capabilities/channel-backend-feed.ts

@@ -0,0 +1,60 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Feed, Filter, Obj, Query } from '@dxos/echo';
+import { createFeedServiceLayer } from '@dxos/echo-client';
+import { invariant } from '@dxos/invariant';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { Channel, Message } from '@dxos/types';
+
+import { ThreadCapabilities } from '../types';
+
+/**
+ * Default local ECHO-feed-backed channel provider. Stores messages in a `Feed`
+ * (`makeConfig` → `Feed.make()`), reads them via a reactive database query, and
+ * writes via `Feed.append`. This is the backend `Channel.make()` defaults to.
+ */
+export const feedChannelBackend: ThreadCapabilities.ChannelBackendProvider = {
+  kind: Channel.FeedBackendKind,
+  label: 'Feed',
+  icon: 'ph--rows--regular',
+  createFields: Schema.Struct({}),
+  makeConfig: () => Feed.make(),
+  subscribe: (channel, onMessages) => {
+    const feed = Channel.getFeed(channel);
+    const db = Obj.getDatabase(channel);
+    if (!feed || !db) {
+      onMessages([]);
+      return () => {};
+    }
+
+    const result = db.query(Query.select(Filter.type(Message.Message)).from(feed));
+    return result.subscribe(() => onMessages(result.results), { fire: true });
+  },
+  send: (channel, message) =>
+    Effect.gen(function* () {
+      const db = Obj.getDatabase(channel);
+      invariant(db, 'Database not found');
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      const space = client.spaces.get(db.spaceId);
+      invariant(space, 'Space not found');
+      const feed = Channel.getFeed(channel);
+      invariant(feed, 'Channel is not feed-backed');
+      yield* Feed.append(feed, [message]).pipe(Effect.provide(createFeedServiceLayer(space.queues)));
+    }),
+  readOnly: (channel) => Obj.getMeta(channel).keys.length > 0,
+};
+
+/** Contributes the default feed-backed channel provider. */
+export const ChannelBackendFeed = Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(ThreadCapabilities.ChannelBackend, feedChannelBackend);
+  }),
+);
+
+export default ChannelBackendFeed;

package/src/capabilities/create-object.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Type } from '@dxos/echo';
+import { SpaceCapabilities, SpaceOperation } from '@dxos/plugin-space';
+import { Channel } from '@dxos/types';
+
+// Lazily loaded (via the #containers barrel) so the react-ui-form dependency
+// graph isn't pulled into this capability module's evaluation.
+import { ChannelCreatePanel } from '#containers';
+
+import { getChannelsPath } from '../paths';
+import { ThreadCapabilities, resolveProvider } from '../types';
+
+type CreateOptions = Parameters<SpaceCapabilities.CreateObjectEntry['createObject']>[1];
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+      id: Type.getTypename(Channel.Channel),
+      customPanel: ChannelCreatePanel,
+      createObject: (
+        { name, kind, options }: { name?: string; kind?: string; options?: Record<string, unknown> },
+        opts: CreateOptions,
+      ) =>
+        Effect.gen(function* () {
+          const providers = yield* Capability.getAll(ThreadCapabilities.ChannelBackend);
+          const provider = kind ? resolveProvider(providers, kind) : undefined;
+          const object = provider
+            ? Channel.make({ name, backend: { kind: provider.kind, config: provider.makeConfig(options ?? {}) } })
+            : Channel.make({ name });
+          return yield* Operation.invoke(SpaceOperation.AddObject, {
+            object,
+            target: opts.target,
+            hidden: true,
+            targetNodeId: opts.targetNodeId ?? getChannelsPath(opts.db.spaceId),
+          });
+        }),
+    });
+  }),
+);

package/src/capabilities/index.ts

@@ -2,15 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/compute';
 
-export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
-export const CallManager = lazy(() => import('./call-manager'));
-export const IntentResolver = lazy(() => import('./intent-resolver'));
-export const Markdown = lazy(() => import('./markdown'));
-export const ReactRoot = lazy(() => import('./react-root'));
-export const ReactSurface = lazy(() => import('./react-surface'));
-export const ThreadSettings = lazy(() => import('./settings'));
-export const ThreadState = lazy(() => import('./state'));
-
-export * from './capabilities';
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const NavigationResolver = Capability.lazy('NavigationResolver', () => import('./navigation-resolver'));
+export const ChannelBackendFeed = Capability.lazy('ChannelBackendFeed', () => import('./channel-backend-feed'));
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));

package/src/capabilities/navigation-resolver.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities, createTypeSectionPathResolver } from '@dxos/app-toolkit';
+import { Channel } from '@dxos/types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(
+      AppCapabilities.NavigationPathResolver,
+      createTypeSectionPathResolver(Channel.Channel),
+    );
+  }),
+);

package/src/capabilities/operation-handler.ts

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

package/src/capabilities/react-surface.tsx

@@ -2,88 +2,48 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
 import React from 'react';
 
-import { Capabilities, contributes, createSurface, useCapability } from '@dxos/app-framework';
-import { Obj, type Ref } from '@dxos/echo';
-import { SettingsStore } from '@dxos/local-storage';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
 import { getSpace } from '@dxos/react-client/echo';
+import { Channel, Thread } from '@dxos/types';
 
-import {
-  CallDebugPanel,
-  CallSidebar,
-  ChannelContainer,
-  ChatContainer,
-  ThreadComplementary,
-  ThreadSettings,
-} from '../components';
-import { THREAD_PLUGIN } from '../meta';
-import { ChannelType, type ThreadSettingsProps, ThreadType } from '../types';
+import { ChannelArticle, ThreadArticle } from '#containers';
 
-import { ThreadCapabilities } from './capabilities';
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: 'channel',
+        filter: AppSurface.object(AppSurface.Article, Channel.Channel),
+        component: ({ data: { subject, attendableId }, role }) => (
+          <ChannelArticle role={role} subject={subject} attendableId={attendableId} />
+        ),
+      }),
+      Surface.create({
+        id: 'chatCompanion',
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'chat'),
+          AppSurface.companion(AppSurface.Article, Channel.Channel),
+        ),
+        component: ({ data: { companionTo: channel } }) => <ChannelArticle subject={channel} />,
+      }),
+      // TODO(burdon): Disambiguate with Channel.
+      Surface.create({
+        id: 'thread',
+        filter: AppSurface.object(AppSurface.Article, Thread.Thread),
+        component: ({ data: { subject } }) => {
+          const space = getSpace(subject);
+          if (!space || !subject) {
+            return null;
+          }
 
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: `${THREAD_PLUGIN}/channel`,
-      role: 'article',
-      filter: (data): data is { subject: ChannelType } => Obj.instanceOf(ChannelType, data.subject),
-      component: ({ data: { subject: channel }, role }) => <ChannelContainer channel={channel} role={role} />,
-    }),
-    createSurface({
-      id: `${THREAD_PLUGIN}/chat-companion`,
-      role: 'article',
-      filter: (data): data is { companionTo: ChannelType; subject: 'chat' } =>
-        Obj.instanceOf(ChannelType, data.companionTo) && data.subject === 'chat',
-      component: ({ data: { companionTo: channel } }) => {
-        const space = getSpace(channel);
-        const thread = channel.defaultThread.target;
-        if (!space || !thread) {
-          return null;
-        }
-
-        return <ChatContainer thread={thread} space={space} />;
-      },
-    }),
-    createSurface({
-      id: `${THREAD_PLUGIN}/thread`,
-      role: 'article',
-      filter: (data): data is { subject: ThreadType } => Obj.instanceOf(ThreadType, data.subject),
-      component: ({ data: { subject: thread } }) => {
-        const space = getSpace(thread);
-        if (!space || !thread) {
-          return null;
-        }
-
-        return <ChatContainer thread={thread} space={space} />;
-      },
-    }),
-    createSurface({
-      id: `${THREAD_PLUGIN}/comments`,
-      role: 'article',
-      filter: (data): data is { companionTo: { threads: Ref.Ref<ThreadType>[] } } =>
-        data.subject === 'comments' && Obj.isObject(data.companionTo),
-      // TODO(wittjosiah): This isn't scrolling properly in a plank.
-      component: ({ data }) => <ThreadComplementary subject={data.companionTo} />,
-    }),
-    createSurface({
-      id: `${THREAD_PLUGIN}/plugin-settings`,
-      role: 'article',
-      filter: (data): data is { subject: SettingsStore<ThreadSettingsProps> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === THREAD_PLUGIN,
-      component: ({ data: { subject } }) => <ThreadSettings settings={subject.value} />,
-    }),
-    createSurface({
-      id: `${THREAD_PLUGIN}/assistant`,
-      role: 'deck-companion--active-call',
-      component: () => <CallSidebar />,
-    }),
-    createSurface({
-      id: `${THREAD_PLUGIN}/devtools-overview`,
-      role: 'devtools-overview',
-      component: () => {
-        const call = useCapability(ThreadCapabilities.CallManager);
-        return <CallDebugPanel state={call.state} />;
-      },
-    }),
-  ]);
+          return <ThreadArticle space={space} thread={subject} />;
+        },
+      }),
+    ]),
+  ),
+);

package/src/components/Chat/Chat.tsx

@@ -0,0 +1,119 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import React, { useCallback, useMemo } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { PublicKey } from '@dxos/react-client';
+import { type SpaceMember } from '@dxos/react-client/echo';
+import { type Identity } from '@dxos/react-client/halo';
+import { composable, Card, type ThemedClassName, useTranslation } from '@dxos/react-ui';
+import { type ObjectTileComponent, Thread } from '@dxos/react-ui-thread';
+import { type Message } from '@dxos/types';
+import { hoverableControls, hoverableFocusedWithinControls, mx } from '@dxos/ui-theme';
+
+import { meta } from '#meta';
+
+import { getMessageMetadata } from '../../util';
+
+export type ChatProps = ThemedClassName<{
+  /** Stable id used for the underlying thread root and message metadata. */
+  id: string;
+  /** Identity used to attribute outgoing messages in the textbox metadata. */
+  identity?: Identity;
+  /** Space members for rendering sender names/avatars on incoming messages. */
+  members: SpaceMember[];
+  /** Messages to render in order. */
+  messages: readonly Message.Message[];
+  /** Activity indicator (e.g. processing) shown beneath the textbox. */
+  activity?: boolean;
+  /** Autofocus textbox */
+  autoFocus?: boolean;
+  /** Marks the thread as the current/attended one. */
+  current?: boolean | string;
+  /**
+   * When true, hide the composer textbox and activity indicator. Used for
+   * channels whose source-of-truth lives elsewhere (e.g. externally-synced
+   * Slack/Discord channels keyed by a foreign id) — sending isn't meaningful
+   * because there is no local-write path back to the source.
+   */
+  readOnly?: boolean;
+  /**
+   * Called with the user's textbox content when they press send.
+   * Returning `true` signals the message was accepted; the textbox is then cleared.
+   */
+  onSend: (text: string) => boolean;
+}>;
+
+/**
+ * Pure chat UI: message list + composer textbox + activity indicator, built on
+ * the `@dxos/react-ui-thread` primitives. Does not load data or invoke
+ * operations — the caller passes messages and an `onSend` callback. Used by
+ * `ChannelArticle` and `ThreadArticle`.
+ */
+export const Chat = composable<HTMLDivElement, ChatProps>(
+  ({ id, identity, members, messages, activity, onSend, autoFocus, current, readOnly }, forwardedRef) => {
+    const { t } = useTranslation(meta.id);
+
+    const components = useMemo(() => ({ Object: ObjectTile }), []);
+
+    const textboxMetadata = useMemo(() => getMessageMetadata(id, identity), [id, identity]);
+
+    const getMetadata = useCallback(
+      (message: Message.Message) => {
+        // TODO(burdon): Factor out.
+        const sender = members.find(
+          (member) =>
+            (message.sender.identityDid && member.identity.did === message.sender.identityDid) ||
+            (message.sender.identityKey && PublicKey.equals(member.identity.identityKey, message.sender.identityKey)),
+        );
+
+        // Pass `message.sender` as the fallback so externally-synced messages
+        // (Slack, etc.) display the source-side sender name instead of "Anonymous"
+        // when no DXOS identity matches.
+        return getMessageMetadata(message.id, sender?.identity, message.sender);
+      },
+      [members],
+    );
+
+    return (
+      <Thread.Root getMetadata={getMetadata} components={components} identityDid={identity?.did} editable={false}>
+        <Thread.Content id={id} current={current} classNames='dx-container' ref={forwardedRef}>
+          <Thread.Messages messages={messages} />
+          {!readOnly && (
+            <>
+              <Thread.Textbox
+                {...textboxMetadata}
+                autoFocus={autoFocus}
+                placeholder={t('message.placeholder')}
+                onSend={onSend}
+              />
+              <Thread.Status activity={activity}>{t('activity.message')}</Thread.Status>
+            </>
+          )}
+        </Thread.Content>
+      </Thread.Root>
+    );
+  },
+);
+
+/**
+ * Object/reference message-block tile, injected into `Thread.Root` so that
+ * `@dxos/react-ui-thread` stays free of `@dxos/app-framework`. Renders the
+ * referenced subject via an app-framework `Surface` (the card role).
+ */
+const ObjectTile: ObjectTileComponent = ({ subject }) => {
+  const Fallback = useCallback(() => <span className='p-1 text-sm text-description'>{subject.id}</span>, [subject]);
+  return (
+    <Card.Root className={mx('grid col-span-3 py-1 pr-4', hoverableControls, hoverableFocusedWithinControls)}>
+      <Surface.Surface
+        type={AppSurface.Card}
+        limit={1}
+        data={{ subject } satisfies AppSurface.ObjectCardData}
+        fallback={Fallback}
+      />
+    </Card.Root>
+  );
+};

package/src/components/Chat/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './Chat';

package/src/components/index.ts

@@ -2,17 +2,4 @@
 // Copyright 2023 DXOS.org
 //
 
-import { lazy } from 'react';
-
-export const ChannelContainer = lazy(() => import('./ChannelContainer'));
-export const ChatContainer = lazy(() => import('./ChatContainer'));
-
-// TODO(wittjosiah): Suspense boundary for sidebar?
-export * from './Call';
-export * from './CallDebugPanel';
-export * from './CallSidebar';
-export * from './CommentsContainer';
-export * from './CommentsThreadContainer';
-export * from './MessageContainer';
-export * from './ThreadComplementary';
-export * from './ThreadSettings';
+export * from './Chat';