@dxos/plugin-sheet 0.8.4-main.7ace549 → 0.8.4-main.8baae0fced

package/src/components/{GridSheet/GridSheet.tsx → SheetContent/SheetContent.tsx}

@@ -8,14 +8,15 @@ import React, {
   type MouseEvent,
   type WheelEvent,
   useCallback,
+  useEffect,
   useMemo,
   useRef,
   useState,
 } from 'react';
 
-import { createIntent } from '@dxos/app-framework';
-import { useIntentDispatcher } from '@dxos/app-framework/react';
-import { type CellRange, rangeToA1Notation } from '@dxos/compute';
+import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { type CellRange, rangeToA1Notation } from '@dxos/compute-hyperformula';
+import { Obj } from '@dxos/echo';
 import { defaultColSize, defaultRowSize } from '@dxos/lit-grid';
 import { DropdownMenu, Icon, useTranslation } from '@dxos/react-ui';
 import { useAttention } from '@dxos/react-ui-attention';
@@ -32,13 +33,15 @@ import {
   editorKeys,
   parseCellIndex,
 } from '@dxos/react-ui-grid';
+import { composable, composableProps } from '@dxos/ui-theme';
 
-import { type RangeController, rangeExtension, sheetExtension } from '../../extensions';
-import { useSelectThreadOnCellFocus, useUpdateFocusedCellOnThreadSelection } from '../../integrations';
-import { meta } from '../../meta';
-import { DEFAULT_COLS, DEFAULT_ROWS, SheetAction } from '../../types';
-import { useSheetContext } from '../SheetContext';
+import { meta } from '#meta';
+import { SheetOperation } from '#types';
+import { DEFAULT_COLS, DEFAULT_ROWS, SheetCapabilities } from '#types';
 
+import { type RangeController, rangeExtension, sheetExtension } from '../../extensions';
+import { useSelectThreadOnCellFocus } from '../../integrations';
+import { useSheetContext } from '../SheetRoot';
 import { colLabelCell, rowLabelCell, useSheetModelDxGridProps } from './util';
 
 const inertPosition: DxGridPosition = { plane: 'grid', col: 0, row: 0 };
@@ -69,15 +72,29 @@ const sheetRowDefault = {
   grid: { size: defaultRowSize, resizeable: true },
 };
 
-export const GridSheet = () => {
+export type SheetContentProps = {};
+
+export const SheetContent = composable<HTMLDivElement, SheetContentProps>((props, forwardedRef) => {
   const { t } = useTranslation(meta.id);
-  const { id, model, editing, setCursor, setRange, cursor, cursorFallbackRange, activeRefs, ignoreAttention } =
-    useSheetContext();
+  const {
+    id,
+    attendableId,
+    model,
+    editing,
+    setCursor,
+    setRange,
+    cursor,
+    cursorFallbackRange,
+    activeRefs,
+    setActiveRefs,
+    ignoreAttention,
+  } = useSheetContext();
+
   // NOTE(thure): using `useState` instead of `useRef` works with refs provided by `@lit/react` and gives us
   //  a reliable dependency for `useEffect` whereas `useLayoutEffect` does not guarantee the element will be defined.
   const [dxGrid, setDxGrid] = useState<DxGridElement | null>(null);
   const [extraplanarFocus, setExtraplanarFocus] = useState<DxGridPosition | null>(null);
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const { invokePromise } = useOperationInvoker();
   const rangeController = useRef<RangeController>(null);
   const { hasAttention } = useAttention(id);
 
@@ -128,15 +145,17 @@ export const GridSheet = () => {
 
   const handleAxisResize = useCallback<NonNullable<GridContentProps['onAxisResize']>>(
     ({ axis, size, index: numericIndex }) => {
-      if (axis === 'row') {
-        const rowId = model.sheet.rows[parseInt(numericIndex)];
-        model.sheet.rowMeta[rowId] ??= {};
-        model.sheet.rowMeta[rowId].size = size;
-      } else {
-        const columnId = model.sheet.columns[parseInt(numericIndex)];
-        model.sheet.columnMeta[columnId] ??= {};
-        model.sheet.columnMeta[columnId].size = size;
-      }
+      Obj.update(model.sheet, (sheet) => {
+        if (axis === 'row') {
+          const rowId = sheet.rows[parseInt(numericIndex)];
+          sheet.rowMeta[rowId] ??= {};
+          sheet.rowMeta[rowId].size = size;
+        } else {
+          const columnId = sheet.columns[parseInt(numericIndex)];
+          sheet.columnMeta[columnId] ??= {};
+          sheet.columnMeta[columnId].size = size;
+        }
+      });
     },
     [model],
   );
@@ -266,24 +285,20 @@ export const GridSheet = () => {
       switch (operation) {
         case 'insert-before':
         case 'insert-after':
-          return dispatch(
-            createIntent(SheetAction.InsertAxis, {
-              model,
-              axis: contextMenuAxis,
-              index: contextMenuOpen![contextMenuAxis] + (operation === 'insert-before' ? 0 : 1),
-            }),
-          );
+          return invokePromise(SheetOperation.InsertAxis, {
+            model,
+            axis: contextMenuAxis,
+            index: contextMenuOpen![contextMenuAxis] + (operation === 'insert-before' ? 0 : 1),
+          });
         case 'drop':
-          return dispatch(
-            createIntent(SheetAction.DropAxis, {
-              model,
-              axis: contextMenuAxis,
-              axisIndex: model.sheet[contextMenuAxis === 'row' ? 'rows' : 'columns'][contextMenuOpen![contextMenuAxis]],
-            }),
-          );
+          return invokePromise(SheetOperation.DropAxis, {
+            model,
+            axis: contextMenuAxis,
+            axisIndex: model.sheet[contextMenuAxis === 'row' ? 'rows' : 'columns'][contextMenuOpen![contextMenuAxis]],
+          });
       }
     },
-    [contextMenuAxis, contextMenuOpen, model, dispatch],
+    [contextMenuAxis, contextMenuOpen, model, invokePromise],
   );
 
   const { columns, rows } = useSheetModelDxGridProps(dxGrid, model);
@@ -315,23 +330,31 @@ export const GridSheet = () => {
     [model],
   );
 
-  useUpdateFocusedCellOnThreadSelection(dxGrid);
+  const [gridInstances] = useCapabilities(SheetCapabilities.GridInstances);
+  useEffect(() => {
+    if (dxGrid && gridInstances) {
+      gridInstances.register(attendableId, dxGrid, setActiveRefs);
+      return () => gridInstances.unregister(attendableId);
+    }
+  }, [dxGrid, gridInstances, attendableId, setActiveRefs]);
+
   useSelectThreadOnCellFocus();
 
   return (
-    // TODO(thure): Why are Table’s and Sheet’s editor boxes off by 1px?
-    <div role='none' className='relative min-bs-0 [&_.cm-editor]:!border-lb [&_.cm-editor]:!border-transparent'>
+    <div ref={forwardedRef} {...composableProps(props, { classNames: 'relative min-h-0' })}>
       <GridCellEditor getCellContent={getCellContent} extensions={extensions} onBlur={handleBlur} />
       <Grid.Content
+        className='[--dx-grid-base:var(--base-surface)] [&_.dx-grid]:absolute [&_.dx-grid]:inset-0'
         initialCells={initialCells}
         limitColumns={DEFAULT_COLS}
         limitRows={DEFAULT_ROWS}
         columns={columns}
         rows={rows}
-        // TODO(burdon): `col` vs. `column`?
         columnDefault={sheetColDefault}
         rowDefault={sheetRowDefault}
+        activeRefs={activeRefs}
         frozen={frozen}
+        overscroll='trap'
         onAxisResize={handleAxisResize}
         onSelect={handleSelect}
         onFocus={handleFocus}
@@ -339,9 +362,6 @@ export const GridSheet = () => {
         onKeyDown={handleKeyDown}
         onContextMenu={handleContextMenu}
         onClick={handleClick}
-        overscroll='trap'
-        className='[--dx-grid-base:var(--baseSurface)] [&_.dx-grid]:absolute [&_.dx-grid]:inset-0'
-        activeRefs={activeRefs}
         ref={setDxGrid}
       />
       <DropdownMenu.Root
@@ -357,27 +377,25 @@ export const GridSheet = () => {
               data-testid={`grid.${contextMenuAxis}.insert-before`}
             >
               <Icon
-                size={5}
                 icon={contextMenuAxis === 'col' ? 'ph--columns-plus-left--regular' : 'ph--rows-plus-top--regular'}
               />
-              <span>{t(`add ${contextMenuAxis} before label`)}</span>
+              <span>{t(`add-${contextMenuAxis}-before.label`)}</span>
             </DropdownMenu.Item>
             <DropdownMenu.Item
               onClick={() => handleAxisMenuAction('insert-after')}
               data-testid={`grid.${contextMenuAxis}.insert-after`}
             >
               <Icon
-                size={5}
                 icon={contextMenuAxis === 'col' ? 'ph--columns-plus-right--regular' : 'ph--rows-plus-bottom--regular'}
               />
-              <span>{t(`add ${contextMenuAxis} after label`)}</span>
+              <span>{t(`add-${contextMenuAxis}-after.label`)}</span>
             </DropdownMenu.Item>
             <DropdownMenu.Item
               onClick={() => handleAxisMenuAction('drop')}
               data-testid={`grid.${contextMenuAxis}.drop`}
             >
-              <Icon size={5} icon='ph--backspace--regular' />
-              <span>{t(`delete ${contextMenuAxis} label`)}</span>
+              <Icon icon='ph--backspace--regular' />
+              <span>{t(`delete-${contextMenuAxis}.label`)}</span>
             </DropdownMenu.Item>
           </DropdownMenu.Viewport>
           <DropdownMenu.Arrow />
@@ -385,4 +403,4 @@ export const GridSheet = () => {
       </DropdownMenu.Root>
     </div>
   );
-};
+});

package/src/components/{RangeList → SheetContent}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './RangeList';
+export * from './SheetContent';

package/src/components/{GridSheet → SheetContent}/util.ts

@@ -4,7 +4,7 @@
 
 import { useEffect, useState } from 'react';
 
-import { inRange } from '@dxos/compute';
+import { inRange } from '@dxos/compute-hyperformula';
 import { createDocAccessor } from '@dxos/echo-db';
 import { cellClassesForFieldType, parseValue } from '@dxos/react-ui-form';
 import {
@@ -19,10 +19,11 @@ import {
   commentedClassName,
   rowToA1Notation,
 } from '@dxos/react-ui-grid';
-import { mx } from '@dxos/react-ui-theme';
+import { mx } from '@dxos/ui-theme';
+
+import { cellClassNameForRange, rangeFromIndex } from '#types';
 
 import { type SheetModel } from '../../model';
-import { cellClassNameForRange, rangeFromIndex } from '../../types';
 
 const createDxGridColumns = (model: SheetModel): DxGridAxisMeta => {
   return model.sheet.columns.reduce(
@@ -96,13 +97,13 @@ const gridCellGetter = (model: SheetModel) => {
 
 export const rowLabelCell = (row: number) => ({
   value: rowToA1Notation(row),
-  className: '!bg-toolbarSurface text-subdued text-end pie-1',
+  className: '!bg-toolbar-surface text-subdued text-end pe-1',
   resizeHandle: 'row',
 });
 
 export const colLabelCell = (col: number) => ({
   value: colToA1Notation(col),
-  className: '!bg-toolbarSurface text-subdued',
+  className: '!bg-toolbar-surface text-subdued',
   resizeHandle: 'col',
 });
 
@@ -114,7 +115,7 @@ const cellGetter = (model: SheetModel) => {
         return getGridCells(nextBounds);
       case 'fixedStartStart': {
         return {
-          '0,0': { className: '!bg-toolbarSurface' },
+          '0,0': { className: '!bg-toolbar-surface' },
         };
       }
       case 'frozenColsStart':

package/src/components/{SheetContext/SheetContext.tsx → SheetRoot/SheetRoot.tsx}

@@ -4,9 +4,13 @@
 
 import React, { type PropsWithChildren, createContext, useCallback, useContext, useState } from 'react';
 
-import { type CellAddress, type CellRange, type CompleteCellRange, type ComputeGraph } from '@dxos/compute';
-import { Obj } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
+import {
+  type CellAddress,
+  type CellRange,
+  type CompleteCellRange,
+  type ComputeGraph,
+} from '@dxos/compute-hyperformula';
+import { raise } from '@dxos/debug';
 import {
   Grid,
   type GridContentProps,
@@ -15,12 +19,13 @@ import {
   useGridContext,
 } from '@dxos/react-ui-grid';
 
+import { type Sheet } from '#types';
+
 import { type SheetModel, useSheetModel } from '../../model';
-import { type Sheet } from '../../types';
 
 export type SheetContextValue = {
   id: string;
-
+  attendableId: string;
   model: SheetModel;
 
   // Cursor state.
@@ -39,29 +44,62 @@ export type SheetContextValue = {
   activeRefs: GridContentProps['activeRefs'];
   setActiveRefs: (activeRefs: GridContentProps['activeRefs']) => void;
 
+  // Flags
+  ignoreAttention?: boolean;
+
   // Events.
   // TODO(burdon): Generalize.
   onInfo?: () => void;
-
-  // Flags
-  ignoreAttention?: boolean;
 };
 
+// TODO(burdon): Use radix context.
 const SheetContext = createContext<SheetContextValue | undefined>(undefined);
 
 export const useSheetContext = (): SheetContextValue => {
-  const context = useContext(SheetContext);
-  invariant(context);
-  return context;
+  return useContext(SheetContext) ?? raise(new Error('Missing SheetContext'));
+};
+
+export type SheetRootProps = {
+  graph: ComputeGraph;
+  sheet: Sheet.Sheet;
+  attendableId: string;
+  readonly?: boolean;
+  ignoreAttention?: boolean;
+} & Pick<SheetContextValue, 'onInfo'>;
+
+export const SheetRoot = ({
+  children,
+  graph,
+  sheet,
+  attendableId,
+  readonly,
+  ignoreAttention,
+  onInfo,
+}: PropsWithChildren<SheetRootProps>) => {
+  const model = useSheetModel(graph, sheet, { readonly });
+  if (!model) {
+    return null;
+  }
+
+  return (
+    <Grid.Root id={attendableId}>
+      <SheetProviderImpl model={model} attendableId={attendableId} onInfo={onInfo} ignoreAttention={ignoreAttention}>
+        {children}
+      </SheetProviderImpl>
+    </Grid.Root>
+  );
 };
 
 const SheetProviderImpl = ({
+  __gridScope,
+  children,
+  attendableId,
+  ignoreAttention,
   model,
   onInfo,
-  ignoreAttention,
-  children,
-  __gridScope,
-}: GridScopedProps<PropsWithChildren<Pick<SheetContextValue, 'onInfo' | 'model' | 'ignoreAttention'>>>) => {
+}: GridScopedProps<
+  PropsWithChildren<Pick<SheetContextValue, 'attendableId' | 'ignoreAttention' | 'model' | 'onInfo'>>
+>) => {
   const { id, editing, setEditing } = useGridContext('SheetProvider', __gridScope);
 
   const [cursor, setCursorInternal] = useState<CellAddress>();
@@ -92,6 +130,7 @@ const SheetProviderImpl = ({
     <SheetContext.Provider
       value={{
         id,
+        attendableId,
         model,
         editing,
         setEditing,
@@ -102,38 +141,12 @@ const SheetProviderImpl = ({
         cursorFallbackRange,
         activeRefs,
         setActiveRefs,
+        ignoreAttention,
         // TODO(burdon): Change to event.
         onInfo,
-        ignoreAttention,
       }}
     >
       {children}
     </SheetContext.Provider>
   );
 };
-
-export type SheetProviderProps = {
-  graph: ComputeGraph;
-  sheet: Sheet.Sheet;
-  readonly?: boolean;
-  ignoreAttention?: boolean;
-} & Pick<SheetContextValue, 'onInfo'>;
-
-export const SheetProvider = ({
-  children,
-  graph,
-  sheet,
-  readonly,
-  ignoreAttention,
-  onInfo,
-}: PropsWithChildren<SheetProviderProps>) => {
-  const model = useSheetModel(graph, sheet, { readonly });
-
-  return !model ? null : (
-    <Grid.Root id={Obj.getDXN(sheet).toString()}>
-      <SheetProviderImpl model={model} onInfo={onInfo} ignoreAttention={ignoreAttention}>
-        {children}
-      </SheetProviderImpl>
-    </Grid.Root>
-  );
-};

package/src/components/{GridSheet → SheetRoot}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './GridSheet';
+export * from './SheetRoot';

package/src/components/{FunctionEditor/FunctionEditor.tsx → SheetStatusbar/SheetStatusbar.tsx}

@@ -4,13 +4,18 @@
 
 import React from 'react';
 
-import { addressToA1Notation, isFormula, rangeToA1Notation } from '@dxos/compute';
+import { addressToA1Notation, isFormula, rangeToA1Notation } from '@dxos/compute-hyperformula';
 import { Icon } from '@dxos/react-ui';
+import { composable, composableProps, mx } from '@dxos/ui-theme';
 
-import { mapFormulaIndicesToRefs } from '../../types';
-import { useSheetContext } from '../SheetContext';
+import { mapFormulaIndicesToRefs } from '#types';
 
-export const FunctionEditor = () => {
+import { useSheetContext } from '../SheetRoot';
+
+export type SheetStatusbarProps = {};
+
+export const SheetStatusbar = composable<HTMLDivElement, SheetStatusbarProps>((props, forwardedRef) => {
+  const { className, ...rest } = composableProps(props);
   const { model, cursor, range } = useSheetContext();
 
   let value;
@@ -26,16 +31,23 @@ export const FunctionEditor = () => {
   }
 
   return (
-    <div className='flex shrink-0 justify-between items-center pli-4 plb-1 text-sm bg-toolbarSurface border-bs !border-subduedSeparator'>
+    <div
+      ref={forwardedRef}
+      {...rest}
+      className={mx(
+        'flex shrink-0 justify-between items-center px-4 py-1 text-sm bg-toolbar-surface border-y !border-subdued-separator',
+        className,
+      )}
+    >
       <div className='flex gap-4 items-center'>
-        <div className='flex is-16 items-center font-mono'>
+        <div className='flex w-16 items-center font-mono'>
           {(range && rangeToA1Notation(range)) || (cursor && addressToA1Notation(cursor))}
         </div>
         <div className='flex gap-2 items-center'>
-          <Icon icon='ph--function--regular' classNames={['text-greenText', formula ? 'visible' : 'invisible']} />
+          <Icon icon='ph--function--regular' classNames={['text-green-text', formula ? 'visible' : 'invisible']} />
           <span className='font-mono'>{value}</span>
         </div>
       </div>
     </div>
   );
-};
+});

package/src/components/{FunctionEditor → SheetStatusbar}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './FunctionEditor';
+export * from './SheetStatusbar';

package/src/components/SheetToolbar/SheetToolbar.stories.tsx

@@ -5,23 +5,23 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React from 'react';
 
-import { withTheme } from '@dxos/react-ui/testing';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
 
-import { translations } from '../../translations';
+import { translations } from '#translations';
 
 import { SheetToolbar } from './SheetToolbar';
 
 const DefaultStory = () => {
-  // TODO(wittjosiah): Depends on SheetProvider.
+  // TODO(wittjosiah): Depends on SheetRoot.
   // return <SheetToolbar id='test' />;
   return <>TODO</>;
 };
 
 const meta = {
-  title: 'plugins/plugin-sheet/Toolbar',
+  title: 'plugins/plugin-sheet/components/Toolbar',
   component: SheetToolbar as any,
   render: DefaultStory,
-  decorators: [withTheme],
+  decorators: [withTheme(), withLayout({ layout: 'fullscreen' })],
   parameters: {
     layout: 'fullscreen',
     translations,

package/src/components/SheetToolbar/SheetToolbar.tsx

@@ -2,36 +2,40 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Atom } from '@effect-atom/atom-react';
-import React, { type PropsWithChildren, useMemo } from 'react';
+import { Atom, type Registry, RegistryContext } from '@effect-atom/atom-react';
+import React, { useContext, useMemo } from 'react';
 
-import { useAppGraph } from '@dxos/app-framework/react';
-import { type CompleteCellRange } from '@dxos/compute';
-import {
-  type ActionGraphProps,
-  MenuProvider,
-  ToolbarMenu,
-  atomFromSignal,
-  createGapSeparator,
-  useMenuActions,
-} from '@dxos/react-ui-menu';
+import { useAppGraph } from '@dxos/app-toolkit/ui';
+import { type CompleteCellRange } from '@dxos/compute-hyperformula';
+import { type ActionGraphProps, Menu, createGapSeparator, useMenuActions } from '@dxos/react-ui-menu';
+import { composable, composableProps } from '@dxos/ui-theme';
 
 import { type SheetModel } from '../../model';
-import { useSheetContext } from '../SheetContext';
-
+import { useSheetContext } from '../SheetRoot';
 import { createAlign, useAlignState } from './align';
 import { createStyle, useStyleState } from './style';
-import { type ToolbarState, useToolbarState } from './useToolbarState';
+import { type ToolbarStateAtom, useToolbarState } from './useToolbarState';
+
+type ToolbarActionsContext = {
+  model: SheetModel;
+  stateAtom: ToolbarStateAtom;
+  registry: Registry.Registry;
+  cursorFallbackRange?: CompleteCellRange;
+  customActions?: Atom.Atom<ActionGraphProps>;
+};
 
-const createToolbarActions = (
-  model: SheetModel,
-  state: ToolbarState,
-  cursorFallbackRange?: CompleteCellRange,
-  customActions?: Atom.Atom<ActionGraphProps>,
-): Atom.Atom<ActionGraphProps> => {
+const createToolbarActions = ({
+  model,
+  stateAtom,
+  registry,
+  cursorFallbackRange,
+  customActions,
+}: ToolbarActionsContext): Atom.Atom<ActionGraphProps> => {
   return Atom.make((get) => {
-    const align = get(atomFromSignal(() => createAlign(model, state, cursorFallbackRange)));
-    const style = get(atomFromSignal(() => createStyle(model, state, cursorFallbackRange)));
+    const state = get(stateAtom);
+    const context = { model, state, stateAtom, registry, cursorFallbackRange };
+    const align = createAlign(context);
+    const style = createStyle(context);
     const gap = createGapSeparator();
 
     const graph: ActionGraphProps = {
@@ -49,35 +53,38 @@ const createToolbarActions = (
   });
 };
 
-export type SheetToolbarProps = PropsWithChildren<{ id: string }>;
+export type SheetToolbarProps = {};
 
-export const SheetToolbar = ({ id }: SheetToolbarProps) => {
-  const { model, cursorFallbackRange } = useSheetContext();
-  const state = useToolbarState({});
-  useAlignState(state);
-  useStyleState(state);
+export const SheetToolbar = composable<HTMLDivElement, SheetToolbarProps>((props, forwardedRef) => {
+  const { attendableId, model, cursorFallbackRange } = useSheetContext();
+  const stateAtom = useToolbarState({});
+  const registry = useContext(RegistryContext);
+  useAlignState(stateAtom);
+  useStyleState(stateAtom);
 
   const { graph } = useAppGraph();
   const customActions = useMemo(() => {
     return Atom.make((get) => {
-      const actions = get(graph.actions(id));
+      const actions = get(graph.actions(attendableId));
       const nodes = actions.filter((action) => action.properties.disposition === 'toolbar');
       return {
         nodes,
-        edges: nodes.map((node) => ({ source: 'root', target: node.id })),
+        edges: nodes.map((node) => ({ source: 'root', target: node.id, relation: 'child' })),
       };
     });
-  }, [graph]);
+  }, [graph, attendableId]);
 
   const actionsCreator = useMemo(
-    () => createToolbarActions(model, state, cursorFallbackRange, customActions),
-    [model, state, cursorFallbackRange, customActions],
+    () => createToolbarActions({ model, stateAtom, registry, cursorFallbackRange, customActions }),
+    [model, stateAtom, registry, cursorFallbackRange, customActions],
   );
-  const menu = useMenuActions(actionsCreator);
+  const menuActions = useMenuActions(actionsCreator);
 
   return (
-    <MenuProvider {...menu} attendableId={id}>
-      <ToolbarMenu />
-    </MenuProvider>
+    <Menu.Root {...menuActions} attendableId={attendableId}>
+      <Menu.Toolbar {...composableProps(props)} ref={forwardedRef} />
+    </Menu.Root>
   );
-};
+});
+
+SheetToolbar.displayName = 'SheetToolbar';