@dxos/plugin-assistant 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

package/src/components/ChatThread/ChatThread.tsx

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type CSSProperties, forwardRef, useCallback, useEffect, useMemo } from 'react';
+import React, { type CSSProperties, forwardRef, useCallback, useEffect, useMemo, useState } from 'react';
 
 import { PublicKey } from '@dxos/keys';
 import { type Identity } from '@dxos/react-client/halo';
@@ -27,13 +27,22 @@ export type ChatThreadProps = ThemedClassName<
 >;
 
 // TODO(burdon): Memo thread position.
-export const ChatThread = forwardRef<MarkdownStreamController, ChatThreadProps>(
+export const ChatThread = forwardRef<MarkdownStreamController | null, ChatThreadProps>(
   (
     { classNames, identity, messages = [], error, cursor = false, fadeIn = true, debug = false, onEvent },
     forwardedRef,
   ) => {
     const controllerRef = useForwardedRef(forwardedRef);
-    const controller = controllerRef.current;
+    const [controller, setController] = useState<MarkdownStreamController | null>(null);
+
+    // Callback ref to capture when MarkdownStream is mounted and trigger re-render.
+    const refCallback = useCallback(
+      (node: MarkdownStreamController | null) => {
+        controllerRef.current = node;
+        setController(node);
+      },
+      [controllerRef],
+    );
 
     const userHue = useMemo(
       () => identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue,
@@ -70,11 +79,15 @@ export const ChatThread = forwardRef<MarkdownStreamController, ChatThreadProps>(
     return (
       <div
         role='none'
-        className={mx('flex bs-full is-full justify-center overflow-hidden', classNames)}
-        style={{ '--user-fill': `var(--dx-${userHue}Fill)` } as CSSProperties}
+        className={mx('flex h-full w-full justify-center overflow-hidden', classNames)}
+        style={
+          {
+            '--user-fill': `var(--color-${userHue}-fill)`,
+          } as CSSProperties
+        }
       >
         <MarkdownStream
-          ref={controllerRef}
+          ref={refCallback}
           registry={componentRegistry}
           cursor={cursor}
           fadeIn={fadeIn}

package/src/components/ChatThread/Link.tsx

@@ -19,7 +19,7 @@ export const ObjectLink = ({ space, dxn }: ObjectLinkProps) => {
 
   const title = (ref.target && Entity.getLabel(ref.target)) ?? ref.target?.id ?? ref.dxn.toString();
   return (
-    <DxAnchor rootclassname='dx-tag--anchor' refid={dxn.toString()}>
+    <DxAnchor rootclassname='dx-tag--anchor' dxn={dxn.toString()}>
       {title}
     </DxAnchor>
   );

package/src/components/ChatThread/registry.tsx

@@ -5,9 +5,10 @@
 import React from 'react';
 
 import { log } from '@dxos/log';
-import { ToggleContainer } from '@dxos/react-ui-components';
+import { TogglePanel } from '@dxos/react-ui-components';
 import {
   PromptWidget,
+  ReasoningWidget,
   ReferenceWidget,
   SelectWidget,
   SuggestionWidget,
@@ -23,12 +24,21 @@ import { type BlockRenderer, type MessageThreadContext } from './sync';
 
 const Fallback = ({ _tag, ...props }: XmlWidgetProps<MessageThreadContext>) => {
   return (
-    <ToggleContainer.Root classNames='rounded-sm'>
-      <ToggleContainer.Header classNames='bg-groupSurface'>{_tag}</ToggleContainer.Header>
-      <ToggleContainer.Content classNames='bg-modalSurface'>
-        <Json classNames='!p-2 text-sm' data={props} />
-      </ToggleContainer.Content>
-    </ToggleContainer.Root>
+    <TogglePanel.Root classNames='rounded-xs'>
+      <TogglePanel.Header classNames='bg-group-surface'>{_tag}</TogglePanel.Header>
+      <TogglePanel.Content classNames='bg-modal-surface'>
+        <Json.Data classNames='p-2! text-sm' data={props} />
+      </TogglePanel.Content>
+    </TogglePanel.Root>
+  );
+};
+
+const Summary = ({ text }: { text: string }) => {
+  return (
+    <TogglePanel.Root classNames='rounded-sm'>
+      <TogglePanel.Header classNames='bg-group-surface'>Conversation summarized</TogglePanel.Header>
+      <TogglePanel.Content classNames='bg-modal-surface'>{text}</TogglePanel.Content>
+    </TogglePanel.Root>
   );
 };
 
@@ -40,21 +50,28 @@ export const componentRegistry: XmlWidgetRegistry = {
   // Widgets
   //
 
-  ['prompt' as const]: {
+  prompt: {
     block: true,
     factory: ({ children }) => {
       const text = getXmlTextChild(children);
       return text ? new PromptWidget(text) : null;
     },
   },
-  ['reference' as const]: {
+  reasoning: {
+    block: true,
+    factory: ({ children }) => {
+      const text = getXmlTextChild(children);
+      return text ? new ReasoningWidget(text) : null;
+    },
+  },
+  reference: {
     block: false,
     factory: ({ children, ref }) => {
       const text = getXmlTextChild(children);
       return text && ref ? new ReferenceWidget(text, ref) : null;
     },
   },
-  ['select' as const]: {
+  select: {
     block: true,
     factory: ({ children }) => {
       const options = children
@@ -63,14 +80,14 @@ export const componentRegistry: XmlWidgetRegistry = {
       return options?.length ? new SelectWidget(options) : null;
     },
   },
-  ['suggestion' as const]: {
+  suggestion: {
     block: true,
     factory: ({ children }) => {
       const text = getXmlTextChild(children);
       return text ? new SuggestionWidget(text) : null;
     },
   },
-  ['summary' as const]: {
+  stats: {
     block: true,
     factory: ({ children }) => {
       const text = getXmlTextChild(children);
@@ -82,24 +99,28 @@ export const componentRegistry: XmlWidgetRegistry = {
   // React
   //
 
-  ['toolCall' as const]: {
+  toolCall: {
     block: true,
     Component: ToolBlock,
   },
-  ['toolResult' as const]: {
+  toolResult: {
     block: true,
     Component: Fallback,
   },
-  ['toolkit' as const]: {
+  toolkit: {
     block: true,
     Component: Fallback,
   },
+  summary: {
+    block: true,
+    Component: Summary,
+  },
 
   //
   // Fallback
   //
 
-  ['json' as const]: {
+  json: {
     block: true,
     Component: Fallback,
   },
@@ -158,13 +179,25 @@ const blockToMarkdownImpl = (context: MessageThreadContext, message: Message.Mes
       return `<toolCall id="${block.toolCallId}" />`;
     }
     case 'toolResult': {
-      context.updateWidget<{ blocks: ContentBlock.Any[] }>(block.toolCallId, ({ blocks = [] }) => ({
+      // TODO(dmaretskyi): the parameter could be undefined, perhaps tool blocks are not arriving in order.
+      context.updateWidget<{ blocks: ContentBlock.Any[] }>(block.toolCallId, ({ blocks = [] } = { blocks: [] }) => ({
         blocks: [...blocks, block],
       }));
       break;
     }
+    case 'stats': {
+      return `<stats>${ContentBlock.createStatsMessage(block)}</stats>`;
+    }
+    case 'reasoning': {
+      const text = block.reasoningText ?? block.redactedText;
+      if (!text) {
+        return;
+      }
+      // TODO(dmaretskyi): The mixed Markdown/XML parser does not support parsing multi-line XML tags.
+      return `<reasoning>${text.replace(/\n/g, ' ').trim()}</reasoning>`;
+    }
     case 'summary': {
-      return `<summary>${ContentBlock.createSummaryMessage(block)}</summary>`;
+      return `<summary>${block.content}</summary>`;
     }
     default: {
       // TODO(burdon): Needs stable ID.

package/src/components/ChatThread/sync.test.ts

@@ -1,3 +1,5 @@
+// @vitest-environment jsdom
+
 //
 // Copyright 2025 DXOS.org
 //
@@ -10,7 +12,7 @@ import { Obj } from '@dxos/echo';
 import { type Mutable } from '@dxos/echo/internal';
 import { type ContentBlock } from '@dxos/types';
 
-import { createMessage } from '../../testing';
+import { createMessage } from '#testing';
 
 import { blockToMarkdown } from './registry';
 import { MessageSyncer, type TextModel } from './sync';
@@ -56,8 +58,8 @@ describe('reducers', () => {
       syncer.append(messages);
       expect(doc.content).toEqual(['<prompt>Hello</prompt>', 'Hi there!', ''].join('\n'));
 
-      Obj.change(messages[1], (m) => {
-        m.blocks.push({ _tag: 'text', text: 'How can I help?' });
+      Obj.change(messages[1], (obj) => {
+        obj.blocks.push({ _tag: 'text', text: 'How can I help?' });
       });
       syncer.append(messages);
       expect(doc.content).toEqual(['<prompt>Hello</prompt>', 'Hi there!', 'How can I help?', ''].join('\n'));
@@ -78,15 +80,15 @@ describe('reducers', () => {
       syncer.append(messages);
       expect(doc.content).toEqual(['<prompt>Hello</prompt>', 'Hi there!'].join('\n'));
 
-      Obj.change(messages[1], (m) => {
-        const block = m.blocks[0] as Mutable<ContentBlock.Text>;
+      Obj.change(messages[1], (obj) => {
+        const block = obj.blocks[0] as Mutable<ContentBlock.Text>;
         block.text = 'Hi there! How are you?';
         block.pending = false;
       });
       syncer.append(messages);
 
-      Obj.change(messages[1], (m) => {
-        m.blocks.push({ _tag: 'text', text: 'How can I help?' });
+      Obj.change(messages[1], (obj) => {
+        obj.blocks.push({ _tag: 'text', text: 'How can I help?' });
       });
       syncer.append(messages);
       expect(doc.content).toEqual(

package/src/components/ChatThread/sync.ts

@@ -73,6 +73,12 @@ export class MessageSyncer {
    * Syncs messages with the editor.
    */
   append(messages: Message.Message[], flush = false): boolean {
+    // TODO(dmaretskyi): MarkdownStream currently does not support streaming XML tags, so we need to remove pending non-text blocks.
+    messages = messages.map((message) => ({
+      ...message,
+      blocks: message.blocks.filter((block) => !block.pending || block._tag === 'text'),
+    }));
+
     // Check if new set of messages.
     if (this._initialMessageId !== messages[0]?.id) {
       this.reset();
@@ -108,13 +114,13 @@ export class MessageSyncer {
   }
 
   private process(messages: Message.Message[], append: (content: string) => void) {
-    log('sync', {
-      doc: this._model.view?.state.doc.length,
-      messages: messages.map((message) => message.blocks.length),
-      currentMessageIndex: this._currentMessageIndex,
-      currentBlockIndex: this._currentBlockIndex,
-      currentBlockContent: this._currentBlockContent,
-    });
+    // console.log('sync', {
+    //   doc: this._model.view?.state.doc.length,
+    //   messages: messages.map((message) => message.blocks.length),
+    //   currentMessageIndex: this._currentMessageIndex,
+    //   currentBlockIndex: this._currentBlockIndex,
+    //   currentBlockContent: this._currentBlockContent,
+    // });
 
     let i = this._currentMessageIndex;
     for (const message of messages.slice(this._currentMessageIndex)) {
@@ -135,7 +141,7 @@ export class MessageSyncer {
             content = currentBlockContent;
           }
 
-          log('append', { message: i, block: j, content });
+          // console.log('append', { message: i, block: j, content });
           this._currentBlockContent = currentBlockContent;
           append(content);
         }

package/src/components/ProcessTree/ProcessTree.stories.tsx

@@ -0,0 +1,109 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Option from 'effect/Option';
+
+import { Process } from '@dxos/functions-runtime';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+
+import { ProcessTree } from './ProcessTree';
+
+const makeProcess = (
+  overrides: Partial<Process.Info> & Pick<Process.Info, 'pid' | 'state'> & { name: string },
+): Process.Info => ({
+  parentPid: null,
+  key: `test.process.${overrides.name}`,
+  params: { name: overrides.name, target: null },
+  error: null,
+  startedAt: Date.now() - 10_000,
+  completedAt: Option.none(),
+  metrics: { wallTime: 0, inputCount: 0, outputCount: 0 },
+  ...overrides,
+});
+
+const seedProcesses: Process.Info[] = [
+  makeProcess({
+    pid: Process.ID.make('97793611-815e-4a67-bc04-60fa67b2c987'),
+    name: 'Trigger watcher',
+    state: Process.State.RUNNING,
+    metrics: { wallTime: 4200, inputCount: 12, outputCount: 3 },
+  }),
+  makeProcess({
+    pid: Process.ID.make('531e9b15-57f5-472c-8cad-f81eb2a5b564'),
+    parentPid: Process.ID.make('97793611-815e-4a67-bc04-60fa67b2c987'),
+    name: 'Summarize document',
+    state: Process.State.SUCCEEDED,
+    completedAt: Option.some(Date.now() - 2_000),
+    metrics: { wallTime: 1500, inputCount: 1, outputCount: 1 },
+  }),
+  makeProcess({
+    pid: Process.ID.make('98c8d4b6-7b20-4267-a6df-4ca227bcb86d'),
+    parentPid: Process.ID.make('97793611-815e-4a67-bc04-60fa67b2c987'),
+    name: 'Translate content',
+    state: Process.State.HYBERNATING,
+    metrics: { wallTime: 800, inputCount: 1, outputCount: 0 },
+  }),
+  makeProcess({
+    pid: Process.ID.make('4d72c688-750b-47f2-87da-8a464e141b74'),
+    name: 'Data pipeline',
+    state: Process.State.FAILED,
+    error: 'Connection timeout',
+    metrics: { wallTime: 3100, inputCount: 5, outputCount: 2 },
+  }),
+  makeProcess({
+    pid: Process.ID.make('030098d2-4e77-4569-ae77-1c6c34bf0136'),
+    name: 'Idle listener',
+    state: Process.State.IDLE,
+  }),
+  makeProcess({
+    pid: Process.ID.make('0c4dca89-0e13-4ad7-aa7a-d10deb8333ed'),
+    name: 'Shutting down',
+    state: Process.State.TERMINATING,
+  }),
+  makeProcess({
+    pid: Process.ID.make('1620e57f-c9bf-4b76-b3b3-10f96c36a8b3'),
+    name: 'Completed cleanup',
+    state: Process.State.TERMINATED,
+    completedAt: Option.some(Date.now() - 5_000),
+  }),
+];
+
+const meta: Meta<typeof ProcessTree> = {
+  title: 'plugins/plugin-assistant/components/ProcessTree',
+  component: ProcessTree,
+  decorators: [withLayout({ layout: 'column', classNames: 'w-(--dx-complementary-sidebar-size)' }), withTheme()],
+} satisfies Meta<typeof ProcessTree>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    processes: seedProcesses,
+  },
+};
+
+export const AllRunning: Story = {
+  args: {
+    processes: [
+      makeProcess({
+        pid: Process.ID.make('1344bac8-745b-44a6-9af6-dc19509a7844'),
+        name: 'Agent alpha',
+        state: Process.State.RUNNING,
+      }),
+      makeProcess({
+        pid: Process.ID.make('b7c9787a-6705-47dc-a197-d37f1adfa338'),
+        name: 'Agent beta',
+        state: Process.State.RUNNING,
+      }),
+      makeProcess({
+        pid: Process.ID.make('43493533-a94c-4072-b18f-c0e0fd806bf5'),
+        name: 'Agent gamma',
+        state: Process.State.RUNNING,
+      }),
+    ],
+  },
+};

package/src/components/ProcessTree/ProcessTree.tsx

@@ -0,0 +1,85 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Match from 'effect/Match';
+import React from 'react';
+
+import { Process } from '@dxos/functions-runtime';
+import { Icon, ScrollArea, Treegrid } from '@dxos/react-ui';
+import { composable, composableProps, mx } from '@dxos/ui-theme';
+
+export type ProcessTreeProps = {
+  processes: readonly Process.Info[];
+  onProcessSelect?: (process: Process.Info) => void;
+};
+
+export const ProcessTree = composable<HTMLDivElement, ProcessTreeProps>(
+  ({ processes, onProcessSelect, ...props }, forwardedRef) => {
+    const filteredProcesses: Process.Info[] = [
+      ...processes.filter((process) => [Process.State.RUNNING, Process.State.HYBERNATING].includes(process.state)),
+      ...processes.filter((process) => [Process.State.IDLE].includes(process.state)).slice(0, 3),
+      ...processes
+        .filter((process) =>
+          [Process.State.SUCCEEDED, Process.State.FAILED, Process.State.TERMINATED].includes(process.state),
+        )
+        .slice(0, 3),
+    ];
+
+    return (
+      <ScrollArea.Root {...composableProps(props, { classNames: 'dx-expander' })} thin ref={forwardedRef}>
+        <ScrollArea.Viewport>
+          <Treegrid.Root gridTemplateColumns='1fr'>
+            {filteredProcesses
+              .filter((process) => process.parentPid === null)
+              .map((process) => {
+                const activeChildren = filteredProcesses.filter(
+                  (candidate) =>
+                    candidate.parentPid?.toString() === process.pid.toString() &&
+                    candidate.state === Process.State.RUNNING,
+                );
+                return (
+                  <Treegrid.Row
+                    key={process.pid.toString()}
+                    id={process.pid.toString()}
+                    parentOf={process.parentPid?.toString()}
+                  >
+                    <Treegrid.Cell
+                      indent
+                      classNames='flex items-center p-1 gap-2 min-w-0'
+                      onClick={() => onProcessSelect?.(process)}
+                    >
+                      <Icon
+                        size={4}
+                        icon={Match.value(process.state).pipe(
+                          Match.when(Process.State.RUNNING, () => 'ph--spinner-gap--regular'),
+                          Match.when(Process.State.SUCCEEDED, () => 'ph--check-circle--regular'),
+                          Match.when(Process.State.FAILED, () => 'ph--warning--regular'),
+                          Match.when(Process.State.HYBERNATING, () => 'ph--spinner--regular'),
+                          Match.when(Process.State.IDLE, () => 'ph--hourglass--regular'),
+                          Match.when(Process.State.TERMINATING, () => 'ph--x-circle--regular'),
+                          Match.when(Process.State.TERMINATED, () => 'ph--x-circle--regular'),
+                          Match.orElse(() => 'ph--spinner-gap--regular'),
+                        )}
+                        classNames={mx(
+                          process.state === Process.State.RUNNING && 'animate-spin',
+                          process.state === Process.State.FAILED && 'text-error-text',
+                          process.state === Process.State.SUCCEEDED && 'text-success-text',
+                        )}
+                      />
+                      <div role='none' className='flex items-center gap-2 text-xs overflow-hidden'>
+                        <span className='text-description'>{process.params.name}</span>
+                        {activeChildren.length > 0 && (
+                          <span className='text-xs text-description ml-1'>{activeChildren[0].params.name}</span>
+                        )}
+                      </div>
+                    </Treegrid.Cell>
+                  </Treegrid.Row>
+                );
+              })}
+          </Treegrid.Root>
+        </ScrollArea.Viewport>
+      </ScrollArea.Root>
+    );
+  },
+);

package/src/components/ProcessTree/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { ProcessTree, type ProcessTreeProps } from './ProcessTree';

package/src/components/TemplateEditor/TemplateEditor.stories.tsx

@@ -45,7 +45,7 @@ const TEMPLATE = trim`
 const DefaultStory = ({ source }: TemplateEditorProps & { source: string }) => {
   const client = useClient();
   const [blueprint] = useState(() => {
-    const space = client.spaces.default;
+    const space = client.spaces.get()[0];
     return space.db.add(
       Blueprint.make({
         key: 'example.com/blueprint/test',
@@ -56,20 +56,16 @@ const DefaultStory = ({ source }: TemplateEditorProps & { source: string }) => {
   });
 
   return (
-    <TemplateEditor
-      classNames='bg-baseSurface is-full max-is-proseMaxWidth'
-      id={blueprint.id}
-      template={blueprint.instructions}
-    />
+    <TemplateEditor classNames='dx-document bg-base-surface' id={blueprint.id} template={blueprint.instructions} />
   );
 };
 
 const meta = {
-  title: 'plugins/plugin-assistant/TemplateEditor',
+  title: 'plugins/plugin-assistant/components/TemplateEditor',
   component: TemplateEditor as any,
   render: DefaultStory,
   decorators: [
-    withTheme,
+    withTheme(),
     withLayout({ layout: 'column' }),
     withClientProvider({
       types: [Blueprint.Blueprint],

package/src/components/TemplateEditor/TemplateEditor.tsx

@@ -3,11 +3,12 @@
 //
 
 import { defaultHighlightStyle, syntaxHighlighting } from '@codemirror/language';
+import { composeRefs } from '@radix-ui/react-compose-refs';
 import React from 'react';
 
 import { type Template } from '@dxos/blueprints';
 import { createDocAccessor } from '@dxos/echo-db';
-import { type ThemedClassName, useThemeContext, useTranslation } from '@dxos/react-ui';
+import { useThemeContext, useTranslation } from '@dxos/react-ui';
 import { useTextEditor } from '@dxos/react-ui-editor';
 import {
   createBasicExtensions,
@@ -16,55 +17,62 @@ import {
   createThemeExtensions,
   decorateMarkdown,
 } from '@dxos/ui-editor';
-import { mx } from '@dxos/ui-theme';
+import { composable, composableProps } from '@dxos/ui-theme';
 import { isNonNullable } from '@dxos/util';
 
-import { meta } from '../../meta';
+import { meta } from '#meta';
 
 import { handlebars, xmlDecorator } from './extensions';
 
-export type TemplateEditorProps = ThemedClassName<{
+export type TemplateEditorProps = {
   id: string;
   template: Template.Template;
   lineNumbers?: boolean;
-}>;
+};
 
-export const TemplateEditor = ({ id, classNames, template, lineNumbers = true }: TemplateEditorProps) => {
-  const { t } = useTranslation(meta.id);
-  const { themeMode } = useThemeContext();
-  const { parentRef } = useTextEditor(() => {
-    const text = template.source?.target;
-    if (!text) {
-      return {};
-    }
+export const TemplateEditor = composable<HTMLDivElement, TemplateEditorProps>(
+  ({ classNames, id, template, lineNumbers = true, ...props }, forwardedRef) => {
+    const { t } = useTranslation(meta.id);
+    const { themeMode } = useThemeContext();
+    const { parentRef } = useTextEditor(() => {
+      const text = template.source?.target;
+      if (!text) {
+        return {};
+      }
 
-    return {
-      initialValue: text.content ?? '',
-      extensions: [
-        createDataExtensions({
-          id,
-          text: createDocAccessor(text, ['content']),
-        }),
-        createBasicExtensions({
-          bracketMatching: false,
-          lineNumbers,
-          lineWrapping: true,
-          placeholder: t('template placeholder'),
-        }),
-        createThemeExtensions({
-          themeMode,
-          slots: { content: { className: '!pie-4' } },
-        }),
-        createMarkdownExtensions(),
-        decorateMarkdown(),
-        handlebars(),
-        // xml(),
-        // NOTE: Since we're using markdown only HTML nodes are parsed.
-        xmlDecorator(),
-        syntaxHighlighting(defaultHighlightStyle),
-      ].filter(isNonNullable),
-    };
-  }, [themeMode, template.source?.target, lineNumbers]);
+      return {
+        initialValue: text.content ?? '',
+        extensions: [
+          createDataExtensions({
+            id,
+            text: createDocAccessor(text, ['content']),
+          }),
+          createBasicExtensions({
+            bracketMatching: false,
+            lineNumbers,
+            lineWrapping: true,
+            placeholder: t('template.placeholder'),
+          }),
+          createThemeExtensions({ themeMode }),
+          createMarkdownExtensions(),
+          decorateMarkdown(),
+          handlebars(),
+          // xml(),
+          // NOTE: Since we're using markdown only HTML nodes are parsed.
+          xmlDecorator(),
+          syntaxHighlighting(defaultHighlightStyle),
+        ].filter(isNonNullable),
+      };
+    }, [themeMode, template.source?.target, lineNumbers]);
 
-  return <div ref={parentRef} className={mx('bs-full overflow-hidden', classNames)} />;
-};
+    return (
+      <div
+        {...composableProps(props, {
+          role: 'none',
+          classNames: ['h-full overflow-hidden', classNames],
+        })}
+        ref={composeRefs(parentRef, forwardedRef)}
+      />
+    );
+  },
+);