@dxos/plugin-thread 0.8.4-main.422d1c7879 → 0.8.4-main.43cb759274

package/src/components/Chat/Chat.tsx

@@ -0,0 +1,259 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import React, { type RefObject, useLayoutEffect, useMemo, useRef, useState } from 'react';
+
+import { type SpaceMember } from '@dxos/react-client/echo';
+import { type Identity } from '@dxos/react-client/halo';
+import { ScrollArea, type ThemedClassName, useThemeContext, useTranslation } from '@dxos/react-ui';
+import { composable, composableProps } from '@dxos/react-ui';
+import {
+  type MessageMetadata,
+  MessageTextbox,
+  Thread as ThreadComponent,
+  type ThreadRootProps,
+  threadLayout,
+} from '@dxos/react-ui-thread';
+import { type Message } from '@dxos/types';
+import { createBasicExtensions, createThemeExtensions, listener, type Extension } from '@dxos/ui-editor';
+import { mx } from '@dxos/ui-theme';
+import { isNonNullable } from '@dxos/util';
+
+import { meta } from '#meta';
+
+import { command } from '../../extensions';
+import { getMessageMetadata } from '../../util';
+import { MessagePanel } from '../MessagePanel';
+
+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;
+    /**
+     * 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;
+    autoFocusTextbox?: boolean;
+    /**
+     * Where the composer sits relative to the messages.
+     * - `'top'` (default) — composer follows the messages at intrinsic height,
+     *   suitable for inline comment threads.
+     * - `'bottom'` — composer pinned to the bottom of the panel, messages
+     *   scrolling above it. Suitable for full-panel multi-party chat.
+     */
+    orientation?: ChatOrientation;
+    /**
+     * 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;
+  } & Pick<ThreadRootProps, 'current'>
+>;
+
+export type ChatOrientation = 'top' | 'bottom';
+
+/**
+ * Pure chat UI: scrollable message list + composer textbox + activity indicator.
+ * Owns its own UI state (textbox content, scroll position, editor extensions) but
+ * does not load data or invoke operations — the caller passes messages and an
+ * `onSend` callback. Used by both `ThreadContainer` (AutoMerge `Thread`) and
+ * `ChannelArticle`'s feed-backed channel chat.
+ */
+export const Chat = composable<HTMLDivElement, ChatProps>(
+  (
+    {
+      id,
+      identity,
+      members,
+      messages,
+      activity,
+      onSend,
+      autoFocusTextbox,
+      current,
+      orientation = 'top',
+      readOnly,
+      ...props
+    },
+    forwardedRef,
+  ) => {
+    const { t } = useTranslation(meta.id);
+    const { themeMode } = useThemeContext();
+
+    const scrollRef = useRef<HTMLDivElement | null>(null);
+    const sentinelRef = useRef<HTMLDivElement | null>(null);
+    const [autoFocus, setAutoFocus] = useState(autoFocusTextbox);
+
+    // Force the editor to remount after a successful send so its content resets.
+    const [_count, _setCount] = useState(0);
+
+    const textboxMetadata = getMessageMetadata(id, identity);
+    const messageRef = useRef('');
+    const extensions = useMemo(
+      () => [
+        createBasicExtensions({ placeholder: t('message.placeholder') }),
+        createThemeExtensions({ themeMode }),
+        listener({ onChange: ({ text }) => (messageRef.current = text) }),
+        command,
+      ],
+      [themeMode, _count],
+    );
+
+    const scrollToEnd = (behavior: ScrollBehavior) =>
+      setTimeout(() => sentinelRef.current?.scrollIntoView({ behavior, block: 'end' }), 10);
+
+    useLayoutEffect(() => {
+      scrollToEnd('instant');
+    }, []);
+    // NOTE: Auto-scroll on new messages is intentionally not implemented here. Smooth-scroll
+    // animations were causing ResizeObserver feedback loops with CodeMirror/ScrollArea. The
+    // proper fix is "scroll only if user is already at the bottom" — deferred to a follow-up.
+
+    const handleSend = () => {
+      const text = messageRef.current;
+      if (!text?.length) {
+        return false;
+      }
+
+      const accepted = onSend(text);
+      if (!accepted) {
+        return false;
+      }
+
+      messageRef.current = '';
+      setAutoFocus(true);
+      scrollToEnd('smooth');
+      _setCount((count) => count + 1);
+      return true;
+    };
+
+    const filteredMessages = messages.filter(isNonNullable);
+    const renderState: ChatRenderState = {
+      messages: filteredMessages,
+      members,
+      activity,
+      extensions,
+      autoFocus,
+      handleSend,
+      textboxMetadata,
+      scrollRef,
+      sentinelRef,
+      readOnly,
+    };
+
+    return orientation === 'bottom' ? (
+      <ChannelLayout
+        {...composableProps(props, { classNames: 'flex flex-col h-full min-h-0' })}
+        id={id}
+        ref={forwardedRef}
+        state={renderState}
+      />
+    ) : (
+      <ThreadLayout
+        {...composableProps(props, { classNames: 'dx-container grid-rows-[1fr_min-content_min-content]' })}
+        id={id}
+        current={current}
+        ref={forwardedRef}
+        state={renderState}
+      />
+    );
+  },
+);
+
+//
+// Internal layout helpers — share state via the ChatRenderState bag.
+//
+
+type ChatRenderState = {
+  messages: Message.Message[];
+  members: SpaceMember[];
+  activity?: boolean;
+  extensions: Extension[];
+  autoFocus?: boolean;
+  handleSend: () => boolean;
+  textboxMetadata: MessageMetadata;
+  scrollRef: RefObject<HTMLDivElement | null>;
+  sentinelRef: RefObject<HTMLDivElement | null>;
+  readOnly?: boolean;
+};
+
+type LayoutProps = React.HTMLAttributes<HTMLDivElement> & {
+  id: string;
+  state: ChatRenderState;
+};
+
+/** Thread layout — composer follows messages at intrinsic height. */
+const ThreadLayout = React.forwardRef<HTMLDivElement, LayoutProps & Pick<ThreadRootProps, 'current'>>(
+  ({ id, current, state, ...props }, ref) => {
+    const { t } = useTranslation(meta.id);
+    const { messages, members, activity, extensions, autoFocus, handleSend, textboxMetadata, sentinelRef, readOnly } =
+      state;
+    return (
+      <ThreadComponent.Root {...props} id={id} current={current} ref={ref}>
+        <ScrollArea.Root classNames='col-span-2' orientation='vertical'>
+          <ScrollArea.Viewport ref={sentinelRef}>
+            <div className={mx(threadLayout, 'place-self-end')}>
+              {messages.map((message) => (
+                <MessagePanel key={message.id} message={message} members={members} />
+              ))}
+            </div>
+          </ScrollArea.Viewport>
+        </ScrollArea.Root>
+        {!readOnly && (
+          <>
+            <MessageTextbox extensions={extensions} autoFocus={autoFocus} onSend={handleSend} {...textboxMetadata} />
+            <ThreadComponent.Status activity={activity}>{t('activity.message')}</ThreadComponent.Status>
+          </>
+        )}
+      </ThreadComponent.Root>
+    );
+  },
+);
+
+/** Channel layout — composer pinned to the bottom, messages scroll above it. */
+const ChannelLayout = React.forwardRef<HTMLDivElement, LayoutProps>(({ id, state, ...props }, ref) => {
+  const { t } = useTranslation(meta.id);
+  const {
+    messages,
+    members,
+    activity,
+    extensions,
+    autoFocus,
+    handleSend,
+    textboxMetadata,
+    scrollRef,
+    sentinelRef,
+    readOnly,
+  } = state;
+  return (
+    <div {...props} id={id} ref={ref}>
+      <div ref={scrollRef} className='flex-1 min-h-0 overflow-y-auto'>
+        {messages.map((message) => (
+          <div key={message.id} className='grid grid-cols-[var(--dx-rail-size)_1fr] w-full'>
+            <MessagePanel message={message} members={members} />
+          </div>
+        ))}
+        <div ref={sentinelRef} />
+      </div>
+      {!readOnly && (
+        <>
+          <div className='shrink-0 grid grid-cols-[var(--dx-rail-size)_1fr]'>
+            <MessageTextbox extensions={extensions} autoFocus={autoFocus} onSend={handleSend} {...textboxMetadata} />
+          </div>
+          <div className='shrink-0 px-2 pb-1 text-xs text-description'>{activity ? t('activity.message') : null}</div>
+        </>
+      )}
+    </div>
+  );
+});

package/src/components/Chat/index.ts

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

package/src/components/CommentsPanel/CommentsPanel.stories.tsx

@@ -6,28 +6,30 @@ import { type Meta, type StoryObj } from '@storybook/react-vite';
 import * as Effect from 'effect/Effect';
 import React from 'react';
 
-import { OperationPlugin, RuntimePlugin } from '@dxos/app-framework';
+import { ProcessManagerPlugin } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
 import { Obj, Query, Relation } from '@dxos/echo';
 import { TestSchema } from '@dxos/echo/testing';
-import { ClientPlugin } from '@dxos/plugin-client';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
 import { initializeIdentity } from '@dxos/plugin-client/testing';
 import { random } from '@dxos/random';
-import { useDatabase, useQuery } from '@dxos/react-client/echo';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { useAsyncEffect } from '@dxos/react-ui';
 import { withLayout, withTheme, Loading } from '@dxos/react-ui/testing';
 import { AnchoredTo, Message, Thread } from '@dxos/types';
 
+import { translations } from '#translations';
+
 import { createCommentThread, createProposalThread } from '../../testing/data';
-import { translations } from '../../translations';
 import { CommentsPanel } from './CommentsPanel';
 
 random.seed(1);
 
 const DefaultStory = () => {
   const identity = useIdentity();
-  const db = useDatabase();
+  const [space] = useSpaces();
+  const db = space?.db;
   const anchors = useQuery(db, Query.type(AnchoredTo.AnchoredTo));
 
   useAsyncEffect(async () => {
@@ -69,8 +71,7 @@ const meta = {
     //  Currently this is required due to useOnEditAnalytics.
     withPluginManager({
       plugins: [
-        OperationPlugin(),
-        RuntimePlugin(),
+        ProcessManagerPlugin(),
         ClientPlugin({
           types: [Message.Message, Thread.Thread, AnchoredTo.AnchoredTo],
           onClientInitialized: ({ client }) =>

package/src/components/CommentsPanel/CommentsPanel.tsx

@@ -41,19 +41,19 @@ export const CommentsPanel = ({ anchors, currentId, showResolvedThreads, ...prop
 
   if (filteredAnchors.length === 0) {
     return (
-      <div role='none' className='p-form-padding'>
+      <div className='p-form-padding'>
         <Message.Root>
-          <Message.Title>
+          <Message.Content>
             <Trans
               {...{
                 t,
                 i18nKey: 'no-comments.message',
                 components: {
-                  commentIcon: <Icon icon='ph--chat-text--regular' size={4} classNames='w-block' />,
+                  commentIcon: <Icon icon='ph--chat-text--regular' size={4} classNames='dx-icon-inline' />,
                 },
               }}
             />
-          </Message.Title>
+          </Message.Content>
         </Message.Root>
       </div>
     );
@@ -63,7 +63,7 @@ export const CommentsPanel = ({ anchors, currentId, showResolvedThreads, ...prop
     <div>
       {filteredAnchors.map((anchor) => {
         const thread = Relation.getSource(anchor) as Thread.Thread;
-        const threadId = Obj.getDXN(thread).toString();
+        const threadId = Obj.getURI(thread);
         return <CommentsThread key={threadId} anchor={anchor} current={currentId === threadId} {...props} />;
       })}
     </div>

package/src/components/CommentsPanel/CommentsThread.tsx

@@ -54,10 +54,10 @@ export const CommentsThread = ({
   const detached = !anchor.anchor;
   const thread = Relation.getSource(anchor) as Thread.Thread;
   const [messages] = useObject(thread, 'messages');
-  const activity = useStatus(space, Obj.getDXN(thread).toString());
+  const activity = useStatus(space, Obj.getURI(thread));
   const threadScrollRef = useRef<HTMLDivElement | null>(null);
 
-  const textboxMetadata = getMessageMetadata(Obj.getDXN(thread).toString(), identity);
+  const textboxMetadata = getMessageMetadata(Obj.getURI(thread), identity);
 
   // TODO(wittjosiah): This is a hack to reset the editor after a message is sent.
   const [state, setState] = useState({});
@@ -97,14 +97,13 @@ export const CommentsThread = ({
 
   return (
     <ThreadComponent.Root
-      id={Obj.getDXN(thread).toString()}
+      id={Obj.getURI(thread)}
       classNames='pt-2 border-b border-subdued-separator last:border-none'
       current={current}
       onClickCapture={handleAttend}
       onFocusCapture={handleAttend}
     >
       <div
-        role='none'
         className={mx(
           'col-span-2 grid grid-cols-[var(--dx-rail-size)_1fr_min-content]',
           hoverableControls,
@@ -118,7 +117,7 @@ export const CommentsThread = ({
         ) : (
           <ThreadComponent.Header>{thread.name}</ThreadComponent.Header>
         )}
-        <div role='none' className={buttonGroupClassNames}>
+        <div className={buttonGroupClassNames}>
           {thread.status === 'staged' && <Tag palette='neutral'>{t('draft.button')}</Tag>}
           {onResolve && !(thread?.status === 'staged') && (
             <IconButton
@@ -147,7 +146,7 @@ export const CommentsThread = ({
 
       {messages?.map((ref) => (
         <MessagePanel
-          key={ref.dxn.toString()}
+          key={ref.uri}
           editable
           message={ref}
           members={members}
@@ -157,16 +156,21 @@ export const CommentsThread = ({
       ))}
 
       {/*
-        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.
+        Autofocus only newly-created (draft) threads. Once the first message is
+        posted the thread transitions from 'staged' → 'active' and stops stealing
+        focus, satisfying the "one scenario only" constraint flagged in the
+        previous TODO (multiple active threads no longer fight for focus).
       */}
-      <MessageTextbox extensions={extensions} onSend={handleComment} {...textboxMetadata} />
+      <MessageTextbox
+        autoFocus={thread.status === 'staged'}
+        extensions={extensions}
+        onSend={handleComment}
+        {...textboxMetadata}
+      />
 
       <ThreadComponent.Status activity={activity}>{t('activity.message')}</ThreadComponent.Status>
 
-      <div role='none' className='h-px -mt-px' ref={threadScrollRef} />
+      <div className='h-px -mt-px' ref={threadScrollRef} />
     </ThreadComponent.Root>
   );
 };

package/src/components/MessagePanel/MessagePanel.tsx

@@ -82,7 +82,10 @@ export const MessagePanel = ({
       (message.sender.identityDid && member.identity.did === message.sender.identityDid) ||
       (message.sender.identityKey && PublicKey.equals(member.identity.identityKey, message.sender.identityKey)),
   )?.identity;
-  const messageMetadata = getMessageMetadata(message.id, senderIdentity);
+  // 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.
+  const messageMetadata = getMessageMetadata(message.id, senderIdentity, message.sender);
   const userIsAuthor = identity?.did === messageMetadata.authorId;
   const proposalBlock = message.blocks.find((block) => block._tag === 'proposal');
   const references = message.blocks.filter((block) => block._tag === 'reference').map((block) => block.reference);
@@ -90,14 +93,14 @@ export const MessagePanel = ({
   return (
     <MessageRoot {...messageMetadata} classNames={[hoverableControls, hoverableFocusedWithinControls]}>
       <MessageHeading authorName={messageMetadata.authorName} timestamp={messageMetadata.timestamp}>
-        <div role='none' className={buttonGroupClassNames}>
+        <div className={buttonGroupClassNames}>
           {userIsAuthor && editable && (
             <IconButton
               data-testid={editing ? 'thread.message.save' : 'thread.message.edit'}
               variant='ghost'
               icon={editing ? 'ph--check--regular' : 'ph--pencil-simple--regular'}
               iconOnly
-              label={t(editing ? 'save message label' : 'edit message label')}
+              label={t(editing ? 'save-message.label' : 'edit-message.label')}
               classNames={[buttonClassNames, hoverableControlItem]}
               onClick={handleEdit}
             />
@@ -188,15 +191,11 @@ const TextboxBlock = ({
     editing && view?.focus();
   }, [editing, view]);
 
-  return <div role='none' ref={parentRef} className='me-4' {...focusAttributes} />;
+  return <div ref={parentRef} className='me-4' {...focusAttributes} />;
 };
 
 const ProposalBlock = ({ block }: { block: ContentBlock.Proposal }) => {
-  return (
-    <div role='none' className='me-4 italic'>
-      {block.text}
-    </div>
-  );
+  return <div className='me-4 italic'>{block.text}</div>;
 };
 
 const MessageBlockObjectTile = forwardRef<HTMLDivElement, { subject: Obj.Unknown }>(({ subject }, forwardedRef) => {

package/src/components/ThreadSettings/ThreadSettings.stories.tsx

@@ -6,7 +6,8 @@ import { type Meta, type StoryObj } from '@storybook/react-vite';
 
 import { withLayout, withTheme } from '@dxos/react-ui/testing';
 
-import { translations } from '../../translations';
+import { translations } from '#translations';
+
 import { ThreadSettings } from './ThreadSettings';
 
 const meta = {

package/src/components/ThreadSettings/ThreadSettings.tsx

@@ -13,7 +13,6 @@ import { type Settings } from '#types';
 
 export type ThreadSettingsProps = AppSurface.SettingsArticleProps<Settings.Settings>;
 
-// TODO(burdon): Settings.
 export const ThreadSettings = ({ settings: _settings }: ThreadSettingsProps) => {
   const { t: _t } = useTranslation(meta.id);
   return <SettingsForm.Viewport></SettingsForm.Viewport>;

package/src/components/index.ts

@@ -4,7 +4,7 @@
 
 import { type ComponentType, lazy } from 'react';
 
-export * from './Call';
+export * from './Chat';
 export * from './CommentsPanel';
 export * from './MessagePanel';
 

package/src/containers/ChannelArticle/ChannelArticle.stories.tsx

@@ -0,0 +1,105 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capability } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Feed, Query } from '@dxos/echo';
+import { createFeedServiceLayer } from '@dxos/echo-db';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { SpacePlugin } from '@dxos/plugin-space/testing';
+import { corePlugins } from '@dxos/plugin-testing';
+import { Config } from '@dxos/react-client';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
+import { withLayout, withTheme, Loading } from '@dxos/react-ui/testing';
+import { Channel, Message, Thread } from '@dxos/types';
+
+import { translations } from '#translations';
+
+import { ThreadPlugin } from '../../ThreadPlugin';
+import { ChannelArticle, type ChannelArticleProps } from './ChannelArticle';
+
+// TODO(wittjosiah): Channel doesn't render full height.
+const DefaultStory = ({ roomId }: ChannelArticleProps) => {
+  const [space] = useSpaces();
+  const [channel] = useQuery(space?.db, Query.type(Channel.Channel));
+  if (!channel) {
+    return <Loading data={{ channel }} />;
+  }
+
+  return <ChannelArticle subject={channel} attendableId='story' roomId={roomId} role='article' />;
+};
+
+const meta = {
+  title: 'plugins/plugin-thread/containers/ChannelArticle',
+  component: ChannelArticle,
+  render: DefaultStory,
+  decorators: [
+    withTheme(),
+    withLayout({ layout: 'column' }),
+    withPluginManager({
+      capabilities: [
+        Capability.contributes(AppCapabilities.Schema, [Channel.Channel, Feed.Feed, Thread.Thread, Message.Message]),
+      ],
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [Channel.Channel, Feed.Feed, Thread.Thread, Message.Message],
+          config: new Config({
+            runtime: {
+              services: {
+                edge: {
+                  url: 'https://edge.dxos.workers.dev/',
+                },
+                iceProviders: [
+                  {
+                    urls: 'https://edge.dxos.workers.dev/ice',
+                  },
+                ],
+              },
+            },
+          }),
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              const { personalSpace } = yield* initializeIdentity(client);
+              const channel = personalSpace.db.add(Channel.make({ name: 'general' }));
+              const feed = yield* Effect.promise(() => channel.feed.load());
+              const seed = [
+                Message.make({ sender: { role: 'user' }, blocks: [{ _tag: 'text', text: 'Hello, channel.' }] }),
+                Message.make({
+                  sender: { role: 'user' },
+                  blocks: [{ _tag: 'text', text: 'Messages are stored in the feed.' }],
+                }),
+              ];
+              yield* Feed.append(feed, seed).pipe(Effect.provide(createFeedServiceLayer(personalSpace.queues)));
+            }),
+        }),
+        SpacePlugin({}),
+        ThreadPlugin(),
+      ],
+    }),
+  ],
+  parameters: {
+    translations,
+  },
+} satisfies Meta<typeof ChannelArticle>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    // Fixed room for testing.
+    subject: undefined,
+    attendableId: 'story',
+    role: 'article',
+    roomId: '04a1d1911703b8e929d0649021a965',
+  },
+};

package/src/containers/ChannelArticle/ChannelArticle.tsx

@@ -0,0 +1,42 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { getSpace } from '@dxos/react-client/echo';
+import { Panel } from '@dxos/react-ui';
+import { type Channel } from '@dxos/types';
+
+import { ChannelChat } from '../ChannelChat';
+
+export type ChannelArticleProps = AppSurface.ObjectArticleProps<
+  Channel.Channel | undefined,
+  {
+    roomId?: string;
+    fullscreen?: boolean;
+  }
+>;
+
+/**
+ * Renders the channel chat. The "Start video call" action and the in-call surface
+ * are contributed by plugin-calls — this container is call-agnostic.
+ */
+// TODO(burdon): Create Radix style layout.
+// TODO(burdon): Restore graph-driven toolbar so plugin-calls can contribute a "Start video call" action (F-1.1).
+export const ChannelArticle = ({ subject: channel }: ChannelArticleProps) => {
+  const space = getSpace(channel);
+
+  if (channel && space) {
+    return (
+      <Panel.Root classNames='dx-document'>
+        <Panel.Content asChild>
+          <ChannelChat classNames='border' space={space} channel={channel} />
+        </Panel.Content>
+      </Panel.Root>
+    );
+  }
+
+  return null;
+};

package/src/containers/ChannelArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { ChannelArticle as default } from './ChannelArticle';