@dxos/react-ui-menu 0.8.4-main.66e292d → 0.8.4-main.69d29f4

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@dxos/react-ui-menu",
-  "version": "0.8.4-main.66e292d",
+  "version": "0.8.4-main.69d29f4",
   "description": "Components for facilitating reactive and consistent menus.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "DXOS.org",
-  "sideEffects": true,
+  "sideEffects": false,
   "type": "module",
   "exports": {
     ".": {
@@ -25,39 +29,38 @@
     "src"
   ],
   "dependencies": {
-    "@preact-signals/safe-react": "^0.9.0",
-    "@preact/signals-react": "^3.3.0",
     "@radix-ui/react-context": "1.1.1",
     "@radix-ui/react-use-controllable-state": "1.1.0",
-    "@dxos/invariant": "0.8.4-main.66e292d",
-    "@dxos/app-graph": "0.8.4-main.66e292d",
-    "@dxos/react-ui-attention": "0.8.4-main.66e292d",
-    "@dxos/keyboard": "0.8.4-main.66e292d",
-    "@dxos/util": "0.8.4-main.66e292d"
+    "@dxos/app-graph": "0.8.4-main.69d29f4",
+    "@dxos/effect": "0.8.4-main.69d29f4",
+    "@dxos/invariant": "0.8.4-main.69d29f4",
+    "@dxos/keyboard": "0.8.4-main.69d29f4",
+    "@dxos/ui-types": "0.8.4-main.69d29f4",
+    "@dxos/react-ui-attention": "0.8.4-main.69d29f4",
+    "@dxos/util": "0.8.4-main.69d29f4"
   },
   "devDependencies": {
-    "@effect-atom/atom-react": "^0.3.4",
-    "@effect/platform": "0.92.1",
-    "@types/react": "~19.2.2",
-    "@types/react-dom": "~19.2.2",
-    "effect": "3.18.3",
-    "react": "~19.2.0",
-    "react-dom": "~19.2.0",
+    "@effect-atom/atom-react": "^0.4.6",
+    "@effect/platform": "0.93.6",
+    "@types/react": "~19.2.7",
+    "@types/react-dom": "~19.2.3",
+    "effect": "3.19.11",
+    "react": "~19.2.3",
+    "react-dom": "~19.2.3",
     "vite": "7.1.9",
-    "@dxos/live-object": "0.8.4-main.66e292d",
-    "@dxos/random": "0.8.4-main.66e292d",
-    "@dxos/react-ui": "0.8.4-main.66e292d",
-    "@dxos/react-ui-theme": "0.8.4-main.66e292d",
-    "@dxos/storybook-utils": "0.8.4-main.66e292d"
+    "@dxos/random": "0.8.4-main.69d29f4",
+    "@dxos/react-ui": "0.8.4-main.69d29f4",
+    "@dxos/ui-theme": "0.8.4-main.69d29f4",
+    "@dxos/storybook-utils": "0.8.4-main.69d29f4"
   },
   "peerDependencies": {
-    "@effect-atom/atom-react": "^0.3.4",
-    "@effect/platform": "^0.80.12",
-    "effect": "^3.13.3",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "@dxos/react-ui": "0.8.4-main.66e292d",
-    "@dxos/react-ui-theme": "0.8.4-main.66e292d"
+    "@effect-atom/atom-react": "^0.4.6",
+    "@effect/platform": "0.93.6",
+    "effect": "3.19.11",
+    "react": "~19.2.3",
+    "react-dom": "~19.2.3",
+    "@dxos/ui-theme": "0.8.4-main.69d29f4",
+    "@dxos/react-ui": "0.8.4-main.69d29f4"
   },
   "publishConfig": {
     "access": "public"

package/src/builder.ts

@@ -3,9 +3,9 @@
 //
 
 import { invariant } from '@dxos/invariant';
+import type { MenuActionProperties, MenuItemGroupProperties } from '@dxos/ui-types';
 
 import type { ActionGraphProps } from './hooks';
-import type { MenuActionProperties, MenuItemGroupProperties } from './types';
 import { createMenuAction, createMenuItemGroup } from './util';
 
 export interface ActionGroupBuilder {

package/src/components/ActionLabel.tsx

@@ -4,16 +4,16 @@
 
 import React from 'react';
 
-import { type ActionGroup, type Action as GraphAction } from '@dxos/app-graph';
+import { type Node } from '@dxos/app-graph';
 import { keySymbols } from '@dxos/keyboard';
 import { type TFunction, toLocalizedString, useTranslation } from '@dxos/react-ui';
-import { descriptionText, mx } from '@dxos/react-ui-theme';
+import { descriptionText, mx } from '@dxos/ui-theme';
+import { type MenuActionProperties } from '@dxos/ui-types';
 
 import { translationKey } from '../translations';
-import { type MenuActionProperties } from '../types';
 import { getShortcut } from '../util';
 
-type Action = GraphAction<MenuActionProperties> | ActionGroup<Omit<MenuActionProperties, 'variant'>>;
+type Action = Node.Action<MenuActionProperties> | Node.ActionGroup<Omit<MenuActionProperties, 'variant'>>;
 
 export const ActionLabel = ({ action }: { action: Action }) => {
   const { t } = useTranslation(translationKey);

package/src/components/DropdownMenu.tsx

@@ -8,6 +8,7 @@ import React, { type MouseEvent, useCallback } from 'react';
 import { type DropdownMenuRootProps, Icon, DropdownMenu as NaturalDropdownMenu } from '@dxos/react-ui';
 
 import { type MenuAction, type MenuItem, type MenuItemGroup } from '../types';
+import { executeMenuAction } from '../util';
 
 import { ActionLabel } from './ActionLabel';
 import { type MenuScopedProps, useMenu, useMenuItems } from './MenuContext';
@@ -60,17 +61,23 @@ const DropdownMenuRoot = ({
     onChange: onOpenChange,
   });
 
+  const { onAction } = useMenu('DropdownMenuRoot', __menuScope);
+
   const handleActionClick = useCallback(
     (action: MenuAction, event: MouseEvent) => {
       if (action.properties?.disabled) {
         return;
       }
       event.stopPropagation();
-      // TODO(thure): Why does Dialog’s modal-ness cause issues if we don’t explicitly close the menu here?
+      // TODO(thure): Why does Dialog's modal-ness cause issues if we don't explicitly close the menu here?
       setOptionsMenuOpen(false);
-      void action.data?.({ parent: group, caller });
+      if (onAction) {
+        onAction(action, { parent: group, caller });
+      } else {
+        void executeMenuAction(action, { parent: group, caller });
+      }
     },
-    [group, caller],
+    [group, caller, onAction],
   );
 
   const items = useMenuItems(group, propsItems);

package/src/components/MenuContext.tsx

@@ -18,6 +18,7 @@ const [MenuContextProvider, useMenu] = createMenuContext<MenuContextValue>(MENU_
 export const menuContextDefaults: MenuContextValue = {
   iconSize: 5,
   useGroupItems: () => null,
+  onAction: undefined,
 };
 
 const useMenuScope = createMenuScope();
@@ -29,10 +30,17 @@ const MenuProvider = ({
   useGroupItems = menuContextDefaults.useGroupItems,
   iconSize = menuContextDefaults.iconSize,
   attendableId,
+  onAction,
 }: MenuProviderProps) => {
   const { scope } = useMenuScope(undefined);
   return (
-    <MenuContextProvider useGroupItems={useGroupItems} iconSize={iconSize} attendableId={attendableId} scope={scope}>
+    <MenuContextProvider
+      useGroupItems={useGroupItems}
+      iconSize={iconSize}
+      attendableId={attendableId}
+      onAction={onAction}
+      scope={scope}
+    >
       {children}
     </MenuContextProvider>
   );

package/src/components/ToolbarMenu.stories.tsx

@@ -2,25 +2,26 @@
 // Copyright 2024 DXOS.org
 //
 
+import { Atom } from '@effect-atom/atom-react';
 import { type Meta, type StoryObj } from '@storybook/react-vite';
-import React, { useCallback, useMemo } from 'react';
+import React, { useMemo } from 'react';
 
 import { faker } from '@dxos/random';
 import { IconButton } from '@dxos/react-ui';
 import { withTheme } from '@dxos/react-ui/testing';
+import { withRegistry } from '@dxos/storybook-utils';
 
 import { MenuProvider, DropdownMenu as NaturalDropdownMenu, ToolbarMenu } from '../components';
-import { useMenuActions } from '../hooks';
+import { type ActionGraphProps, useMenuActions } from '../hooks';
 import { createActions, createNestedActions, createNestedActionsResolver, useMutateActions } from '../testing';
 import { translations } from '../translations';
-import { type MenuAction } from '../types';
 
 faker.seed(1234);
 
 const meta = {
   title: 'ui/react-ui-menu/ToolbarMenu',
   component: ToolbarMenu,
-  decorators: [withTheme],
+  decorators: [withTheme, withRegistry],
   parameters: {
     translations,
   },
@@ -32,12 +33,18 @@ type Story = StoryObj<typeof meta>;
 
 export const DropdownMenu: Story = {
   render: () => {
-    const menuActions = useMemo(() => createActions() as MenuAction[], []);
-    const resolveGroupItems = useCallback(() => menuActions, [menuActions]);
-    useMutateActions(menuActions);
+    const actionsAtom = useMemo(() => {
+      const actions = createActions();
+      return Atom.make<ActionGraphProps>({
+        nodes: actions,
+        edges: actions.map((action) => ({ source: 'root', target: action.id })),
+      }).pipe(Atom.keepAlive);
+    }, []);
+    useMutateActions(actionsAtom);
+    const menu = useMenuActions(actionsAtom);
 
     return (
-      <MenuProvider useGroupItems={resolveGroupItems}>
+      <MenuProvider {...menu}>
         <NaturalDropdownMenu.Root>
           <NaturalDropdownMenu.Trigger asChild>
             <IconButton icon='ph--list-checks--regular' label='Options' />
@@ -62,6 +69,7 @@ export const Toolbar: Story = {
 
 export const UseMenuActionsToolbar: Story = {
   render: () => {
+    useMutateActions(createNestedActions);
     const menu = useMenuActions(createNestedActions);
 
     return (

package/src/components/ToolbarMenu.tsx

@@ -6,12 +6,12 @@ import React, { Fragment, useCallback } from 'react';
 
 import { Icon, Toolbar as NaturalToolbar, type ToolbarRootProps, useTranslation } from '@dxos/react-ui';
 import { useAttention } from '@dxos/react-ui-attention';
-import { mx, textBlockWidth, toolbarInactive, toolbarLayout } from '@dxos/react-ui-theme';
+import { mx, textBlockWidth, toolbarInactive, toolbarLayout } from '@dxos/ui-theme';
+import { type MenuActionProperties } from '@dxos/ui-types';
 
 import { translationKey } from '../translations';
 import {
   type MenuAction,
-  type MenuActionProperties,
   type MenuItem,
   type MenuItemGroup,
   type MenuMultipleSelectActionGroup,
@@ -19,6 +19,7 @@ import {
   isMenuGroup,
   isSeparator,
 } from '../types';
+import { executeMenuAction } from '../util';
 
 import { ActionLabel, actionLabel } from './ActionLabel';
 import { DropdownMenu } from './DropdownMenu';
@@ -53,7 +54,7 @@ export type ToolbarMenuActionProps = {
 };
 
 const ActionToolbarItem = ({ action, __menuScope }: MenuScopedProps<{ action: MenuAction }>) => {
-  const { iconSize } = useMenu('ActionToolbarItem', __menuScope);
+  const { iconSize, onAction } = useMenu('ActionToolbarItem', __menuScope);
   const { t } = useTranslation(translationKey);
 
   const { icon, iconOnly = true, disabled, testId, hidden, classNames } = action.properties;
@@ -62,7 +63,13 @@ const ActionToolbarItem = ({ action, __menuScope }: MenuScopedProps<{ action: Me
     ? { icon, size: iconSize, iconOnly, label: actionLabel(action, t) }
     : { children: <ActionLabel action={action} /> };
 
-  const handleClick = useCallback(() => action.data?.(), [action]);
+  const handleClick = useCallback(() => {
+    if (onAction) {
+      onAction(action, {});
+    } else {
+      void executeMenuAction(action);
+    }
+  }, [action, onAction]);
 
   return hidden ? null : (
     <Root
@@ -95,7 +102,13 @@ const DropdownMenuToolbarItem = ({
   const Root = icon ? NaturalToolbar.IconButton : NaturalToolbar.Button;
   const labelAction = (group.properties as any).applyActive && activeItem ? (activeItem as MenuAction) : group;
   const rootProps = icon
-    ? { icon, size: iconSize, iconOnly, label: actionLabel(labelAction, t), caretDown: true }
+    ? {
+        icon,
+        size: iconSize,
+        iconOnly,
+        label: actionLabel(labelAction, t),
+        caretDown: true,
+      }
     : {
         children: (
           <>
@@ -115,10 +128,16 @@ const DropdownMenuToolbarItem = ({
 };
 
 const ToggleGroupItem = ({ group, action, __menuScope }: MenuScopedProps<ToolbarMenuActionProps>) => {
-  const { iconSize } = useMenu('ToggleGroupItem', __menuScope);
+  const { iconSize, onAction } = useMenu('ToggleGroupItem', __menuScope);
   const { t } = useTranslation(translationKey);
   const { icon, iconOnly = true, disabled, testId, hidden, classNames } = action.properties;
-  const handleClick = useCallback(() => action.data?.({ parent: group }), [action, group]);
+  const handleClick = useCallback(() => {
+    if (onAction) {
+      onAction(action, { parent: group });
+    } else {
+      void executeMenuAction(action, { parent: group });
+    }
+  }, [action, group, onAction]);
   const Root = icon ? NaturalToolbar.ToggleGroupIconItem : NaturalToolbar.ToggleGroupItem;
   const rootProps = icon
     ? { icon, size: iconSize, iconOnly, label: actionLabel(action, t) }
@@ -164,14 +183,14 @@ const ToggleGroupToolbarItem = ({
 export const ToolbarMenu = ({
   __menuScope,
   classNames,
-  textBlockWidth: textBlockWidthParam,
+  textBlockWidth: textBlockWidthProp,
   ...props
 }: MenuScopedProps<ToolbarMenuProps>) => {
   const items = useMenuItems(undefined, undefined, 'ToolbarMenu', __menuScope);
   const { attendableId } = useMenu('ToolbarMenu', __menuScope);
   const { hasAttention } = useAttention(attendableId);
-  const InnerRoot = textBlockWidthParam ? 'div' : Fragment;
-  const innerRootProps = textBlockWidthParam
+  const InnerRoot = textBlockWidthProp ? 'div' : Fragment;
+  const innerRootProps = textBlockWidthProp
     ? { role: 'none', className: mx(textBlockWidth, toolbarLayout, 'bs-full') }
     : {};
 
@@ -179,7 +198,7 @@ export const ToolbarMenu = ({
     <NaturalToolbar.Root
       {...props}
       classNames={[attendableId && !hasAttention && toolbarInactive, classNames]}
-      layoutManaged={textBlockWidthParam}
+      layoutManaged={textBlockWidthProp}
     >
       <InnerRoot {...innerRootProps}>
         {items?.map((item: MenuItem, i: number) => (

package/src/hooks/useMenuActions.ts

@@ -3,13 +3,13 @@
 //
 
 import { type Atom, RegistryContext, useAtomValue } from '@effect-atom/atom-react';
-import { useCallback, useContext, useEffect, useState } from 'react';
+import { useCallback, useContext, useRef } from 'react';
 
-import { type Edge, type Edges, Graph, type Node, type NodeArg, ROOT_ID } from '@dxos/app-graph';
+import { Graph, Node } from '@dxos/app-graph';
 
 import { type MenuItem, type MenuItemGroup } from '../types';
 
-const edgesArrayToRecord = (edges: Edge[]): Record<string, Edges> => {
+const edgesArrayToRecord = (edges: Graph.Edge[]): Record<string, Graph.Edges> => {
   return Object.fromEntries(
     Object.entries(
       edges.reduce((acc: Record<string, { inbound: string[]; outbound: string[] }>, { source, target }) => {
@@ -36,8 +36,8 @@ const edgesArrayToRecord = (edges: Edge[]): Record<string, Edges> => {
   );
 };
 
-export type ActionGraphNodes = NodeArg<any>[];
-export type ActionGraphEdges = Edge[];
+export type ActionGraphNodes = Node.NodeArg<any>[];
+export type ActionGraphEdges = Graph.Edge[];
 export type ActionGraphProps = {
   nodes: ActionGraphNodes;
   edges: ActionGraphEdges;
@@ -51,22 +51,28 @@ export const useMenuActions = (props: Atom.Atom<ActionGraphProps>): MenuActions
   const registry = useContext(RegistryContext);
   const menuGraphProps = useAtomValue(props);
 
-  const [graph] = useState(
-    new Graph({
+  // Create graph once, then update it when props change.
+  const graphRef = useRef<Graph.WritableGraph | null>(null);
+  if (!graphRef.current) {
+    graphRef.current = Graph.make({
       registry,
-      nodes: menuGraphProps.nodes as Node[],
+      nodes: menuGraphProps.nodes as Node.Node[],
       edges: edgesArrayToRecord(menuGraphProps.edges),
-    }),
-  );
+    });
+  }
+  const graph = graphRef.current;
 
-  useEffect(() => {
-    graph.addNodes(menuGraphProps.nodes);
-    graph.addEdges(menuGraphProps.edges);
-  }, [menuGraphProps]);
+  // Update graph nodes synchronously when props change (before render completes).
+  // Using a ref to track the previous value to detect changes.
+  const prevPropsRef = useRef(menuGraphProps);
+  if (prevPropsRef.current !== menuGraphProps) {
+    prevPropsRef.current = menuGraphProps;
+    graph.pipe(Graph.addNodes(menuGraphProps.nodes), Graph.addEdges(menuGraphProps.edges));
+  }
 
   const useGroupItems = useCallback(
     (sourceNode?: MenuItemGroup) => {
-      const items = useAtomValue(graph.connections(sourceNode?.id || ROOT_ID)) as MenuItem[];
+      const items = useAtomValue(graph.connections(sourceNode?.id || Node.RootId)) as MenuItem[];
       return items;
     },
     [graph],

package/src/index.ts

@@ -2,8 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
-export { atomFromSignal } from '@dxos/app-graph';
-
 export * from './components';
 export * from './hooks';
 export * from './types';

package/src/testing/generator.ts

@@ -2,27 +2,17 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom } from '@effect-atom/atom-react';
-import { useEffect } from 'react';
+import { Atom, RegistryContext } from '@effect-atom/atom-react';
+import { useContext, useEffect } from 'react';
 
-import {
-  ACTION_GROUP_TYPE,
-  ACTION_TYPE,
-  type Action,
-  Graph,
-  type NodeArg,
-  ROOT_ID,
-  actionGroupSymbol,
-} from '@dxos/app-graph';
-import { live } from '@dxos/live-object';
+import { Graph, Node } from '@dxos/app-graph';
 import { faker } from '@dxos/random';
-import { type DeepWriteable } from '@dxos/util';
 
 import { type ActionGraphProps } from '../hooks/useMenuActions';
-import { type MenuAction, type MenuItem, type MenuItemGroup } from '../types';
+import { type MenuItem, type MenuItemGroup } from '../types';
 
-export type CreateActionsParams = Partial<{
-  type?: typeof ACTION_TYPE | typeof ACTION_GROUP_TYPE;
+export type CreateActionsProps = Partial<{
+  type?: typeof Node.ActionType | typeof Node.ActionGroupType;
   callback: () => void;
   count: number;
 }>;
@@ -46,29 +36,27 @@ const icons = {
   ],
 };
 
-export const createActions = (params?: CreateActionsParams) => {
-  // eslint-disable-next-line no-console
-  const { callback = () => console.log('invoke'), count = 12, type = ACTION_TYPE } = params ?? {};
+export const createActions = (params?: CreateActionsProps) => {
+  const { callback = () => console.log('invoke'), count = 12, type = Node.ActionType } = params ?? {};
   return faker.helpers.multiple(
-    () =>
-      live({
-        id: faker.string.uuid(),
-        type,
-        data: type === ACTION_GROUP_TYPE ? actionGroupSymbol : callback,
-        properties: {
-          label: faker.lorem.words(2),
-          icon: faker.helpers.arrayElement(icons[faker.helpers.arrayElement(Object.keys(icons)) as keyof typeof icons]),
-          disabled: faker.helpers.arrayElement([true, false]),
-          ...(type === ACTION_GROUP_TYPE && { variant: 'dropdownMenu' }),
-        },
-      }),
+    () => ({
+      id: faker.string.uuid(),
+      type,
+      data: type === Node.ActionGroupType ? Node.actionGroupSymbol : callback,
+      properties: {
+        label: faker.lorem.words(2),
+        icon: faker.helpers.arrayElement(icons[faker.helpers.arrayElement(Object.keys(icons)) as keyof typeof icons]),
+        disabled: faker.helpers.arrayElement([true, false]),
+        ...(type === Node.ActionGroupType && { variant: 'dropdownMenu' }),
+      },
+    }),
     { count },
   );
 };
 
-export const createNestedActions = Atom.make(() => {
+const buildNestedActions = (): ActionGraphProps => {
   const result: ActionGraphProps = { edges: [], nodes: [] };
-  const actionGroups = createActions({ type: ACTION_GROUP_TYPE });
+  const actionGroups = createActions({ type: Node.ActionGroupType });
   actionGroups.forEach((group) => {
     const actions = createActions();
     result.nodes.push(group, ...actions);
@@ -78,39 +66,56 @@ export const createNestedActions = Atom.make(() => {
     );
   });
   return result;
-});
+};
+
+export const createNestedActions = Atom.make(buildNestedActions()).pipe(Atom.keepAlive);
 
-export const createNestedActionsResolver = (groupParams?: CreateActionsParams, params?: CreateActionsParams) => {
-  const graph = new Graph();
-  const actionGroups = createActions({ type: ACTION_GROUP_TYPE, ...groupParams });
+export const createNestedActionsResolver = (groupParams?: CreateActionsProps, params?: CreateActionsProps) => {
+  const graph = Graph.make();
+  const actionGroups = createActions({ type: Node.ActionGroupType, ...groupParams });
   actionGroups.forEach((group) => {
     const actions = createActions(params);
-    graph.addNodes([group as NodeArg<any>, ...(actions as NodeArg<any>[])]);
-    graph.addEdges([
-      { source: 'root', target: group.id },
-      ...actions.map((action) => ({ source: group.id, target: action.id })),
-    ]);
-    void graph.expand(group.id);
+    graph.pipe(
+      Graph.addNodes([group as Node.NodeArg<any>, ...(actions as Node.NodeArg<any>[])]),
+      Graph.addEdges([
+        { source: 'root', target: group.id },
+        ...actions.map((action) => ({ source: group.id, target: action.id })),
+      ]),
+      Graph.expand(group.id),
+    );
   });
   const resolveGroupItems = (groupNode?: MenuItemGroup) =>
-    (graph.getActions(groupNode?.id ?? ROOT_ID) || null) as MenuItem[] | null;
+    (Graph.getActions(graph, groupNode?.id ?? Node.RootId) || null) as MenuItem[] | null;
   return { resolveGroupItems };
 };
 
-export const mutateActionsOnInterval = (actions: Action[]) => {
-  let cursor = 0;
-  return setInterval(() => {
-    const action = actions[cursor] as DeepWriteable<Action>;
-    action.properties.icon = faker.helpers.arrayElement(
-      action.properties.icon.endsWith('regular') ? icons.fill : icons.regular,
-    );
-    action.properties.disabled = !action.properties.disabled;
-    cursor = (cursor + actions.length + 1) % actions.length;
-  }, 1_000);
-};
+/**
+ * Hook to mutate actions in an atom on an interval for testing reactivity.
+ */
+export const useMutateActions = (actionsAtom: Atom.Writable<ActionGraphProps>) => {
+  const registry = useContext(RegistryContext);
 
-export const useMutateActions = (actions: MenuAction[]) =>
   useEffect(() => {
-    const interval = mutateActionsOnInterval(actions);
+    let cursor = 0;
+    const interval = setInterval(() => {
+      const current = registry.get(actionsAtom);
+      const nodes = current.nodes.map((node, index) => {
+        if (index !== cursor) {
+          return node;
+        }
+        return {
+          ...node,
+          properties: {
+            ...node.properties,
+            icon: faker.helpers.arrayElement(node.properties?.icon?.endsWith('regular') ? icons.fill : icons.regular),
+            disabled: !node.properties?.disabled,
+          },
+        };
+      });
+      registry.set(actionsAtom, { ...current, nodes });
+      cursor = (cursor + 1) % current.nodes.length;
+    }, 1_000);
+
     return () => clearInterval(interval);
-  }, []);
+  }, [actionsAtom, registry]);
+};

package/src/translations.ts

@@ -4,7 +4,7 @@
 
 import { type Resource } from '@dxos/react-ui';
 
-export const translationKey = 'react-ui-menu';
+export const translationKey = '@dxos/react-ui-menu';
 
 export const translations = [
   {

package/src/types.ts

@@ -2,51 +2,37 @@
 // Copyright 2025 DXOS.org
 //
 
-import { ACTION_GROUP_TYPE, type Action, type ActionGroup, type Node } from '@dxos/app-graph';
-import { type ClassNameValue, type IconButtonProps, type Label, type ToolbarSeparatorProps } from '@dxos/react-ui';
-
-export type MenuActionProperties = {
-  label: Label;
-  icon?: string;
-  value?: string;
-  disabled?: boolean;
-  hidden?: boolean;
-  iconOnly?: boolean;
-  testId?: string;
-  variant?: 'action' | 'toggle';
-  checked?: boolean;
-  classNames?: ClassNameValue;
-};
-
-export type MenuItemGroupProperties = {
-  label: Label;
-  icon?: string;
-  iconOnly?: boolean;
-};
+import { Node } from '@dxos/app-graph';
+import { type IconButtonProps, type ToolbarSeparatorProps } from '@dxos/react-ui';
+import { type MenuActionProperties } from '@dxos/ui-types';
 
-export type MenuAction<P extends {} = {}> = Action<P & MenuActionProperties>;
+export type MenuAction<P extends {} = {}> = Node.Action<P & MenuActionProperties>;
 
 export const MenuSeparatorType = '@dxos/react-ui-toolbar/separator' as const;
 
-export type MenuSeparator = Node<never, Pick<ToolbarSeparatorProps, 'variant'>> & {
+export type MenuSeparator = Node.Node<never, Pick<ToolbarSeparatorProps, 'variant'>> & {
   type: typeof MenuSeparatorType;
 };
 
-export const isSeparator = (node: Node): node is MenuSeparator => node.type === MenuSeparatorType;
+export const isSeparator = (node: Node.Node): node is MenuSeparator => node.type === MenuSeparatorType;
 
 export type MenuSingleSelectActionGroup = { selectCardinality: 'single'; value: string };
 export type MenuMultipleSelectActionGroup = { selectCardinality: 'multiple'; value: string[] };
 
-export type MenuItemGroup<P extends Record<string, any> = Record<string, any>> = ActionGroup<P>;
+export type MenuItemGroup<P extends Record<string, any> = Record<string, any>> = Node.ActionGroup<P>;
 
-export const isMenuGroup = (node: Node): node is MenuItemGroup => node.type === ACTION_GROUP_TYPE;
+export const isMenuGroup = (node: Node.Node): node is MenuItemGroup => node.type === Node.ActionGroupType;
 
 export type MenuItem = MenuSeparator | MenuAction | MenuItemGroup;
 
 export type MenuItemsResolver = (group?: MenuItemGroup) => MenuItem[] | null;
 
+export type ActionExecutor = (action: MenuAction, params: Node.InvokeProps) => void;
+
 export type MenuContextValue = {
   useGroupItems: MenuItemsResolver;
   iconSize: IconButtonProps['size'];
   attendableId?: string;
+  /** Optional action executor. If provided, will be used instead of default execution. */
+  onAction?: ActionExecutor;
 };