diff --git a/packages/menu/README.md b/packages/menu/README.md
index 8c64ee2de..7e12bd282 100644
--- a/packages/menu/README.md
+++ b/packages/menu/README.md
@@ -18,6 +18,8 @@ Check out [storybook](https://zendeskgarden.github.io/react-containers) for live
 
 ### useMenu
 
+#### Menu items
+
 ```jsx
 import { useMenu } from '@zendeskgarden/container-menu';
 
@@ -50,6 +52,40 @@ const Menu = () => {
 };
 ```
 
+#### Menu links
+
+```jsx
+import { useMenu } from '@zendeskgarden/container-menu';
+
+const Menu = () => {
+  const triggerRef = useRef();
+  const menuRef = useRef();
+  const items = [
+    { value: 'home', label: 'Home', href="#", selected: true },
+    { value: 'about', label: 'About', href="www.example.com/about" },
+    { value: 'support', label: 'Support', href="www.support.example.com", external: true }
+  ];
+  const { isExpanded, getTriggerProps, getMenuProps, getItemProps, getAnchorProps } = useMenu({
+    triggerRef,
+    menuRef,
+    items
+  });
+
+  return (
+    <>
+      <button {...getTriggerProps()}>Menu</button>
+      <ul {...getMenuProps()} style={{ visibility: isExpanded ? 'visible' : 'hidden' }}>
+        {items.map(item => (
+          <li key={item.value} {...getItemProps({ item })}>
+            <a {...getAnchorProps({ item })}>{item.label}</a>
+          </li>
+        ))}
+      </ul>
+    </>
+  );
+};
+```
+
 ### MenuContainer
 
 ```jsx
@@ -61,27 +97,20 @@ const Menu = () => {
   const items = [
     { value: 'value-1', label: 'One' },
     { value: 'value-2', label: 'Two' },
-    { value: 'value-3', label: 'Three', href: '#0' },
-    { value: 'value-4', label: 'Four' }
+    { value: 'value-3', label: 'Three' }
   ];
 
   return (
     <MenuContainer triggerRef={triggerRef} menuRef={menuRef} items={items}>
-      {({ isExpanded, getTriggerProps, getMenuProps, getItemProps, getSeparatorProps }) => (
+      {({ isExpanded, getTriggerProps, getMenuProps, getItemProps }) => (
         <>
           <button {...getTriggerProps()}>Menu</button>
           <ul {...getMenuProps()} style={{ visibility: isExpanded ? 'visible' : 'hidden' }}>
-            {items.map(item =>
-              item.href ? (
-                <li key={item.value} role="none">
-                  <a {...getItemProps({ item })}>{item.label}</a>
-                </li>
-              ) : (
-                <li key={item.value} {...getItemProps({ item })}>
-                  {item.label}
-                </li>
-              )
-            )}
+            {items.map(item => (
+              <li key={item.value} {...getItemProps({ item })}>
+                {item.label}
+              </li>
+            ))}
           </ul>
         </>
       )}
diff --git a/packages/menu/demo/menu.stories.tsx b/packages/menu/demo/menu.stories.tsx
index 76723ddab..ddd81132d 100644
--- a/packages/menu/demo/menu.stories.tsx
+++ b/packages/menu/demo/menu.stories.tsx
@@ -48,6 +48,8 @@ export const Controlled: Story = {
     return (
       <MenuStory
         {...args}
+        // Storybook sets args to null when they are removed from controls. This breaks useMenu since getControlledValue treats null as intentional input.
+        selectedItems={args.selectedItems === null ? undefined : args.selectedItems}
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         onChange={({ type, ...rest }) => {
           updateArgs(rest);
diff --git a/packages/menu/demo/stories/MenuStory.tsx b/packages/menu/demo/stories/MenuStory.tsx
index a60b8ecf8..4fc2a225e 100644
--- a/packages/menu/demo/stories/MenuStory.tsx
+++ b/packages/menu/demo/stories/MenuStory.tsx
@@ -5,7 +5,7 @@
  * found at http://www.apache.org/licenses/LICENSE-2.0.
  */
 
-import React, { AnchorHTMLAttributes, LiHTMLAttributes, useRef } from 'react';
+import React, { useEffect, useRef } from 'react';
 import { StoryFn } from '@storybook/react';
 import classNames from 'classnames';
 import {
@@ -29,18 +29,20 @@ interface IUseMenuComponentProps extends MenuReturnValue {
 type MenuItemProps = {
   item: IMenuItemBase;
   getItemProps: IUseMenuComponentProps['getItemProps'];
+  getAnchorProps: IUseMenuComponentProps['getAnchorProps'];
   focusedValue: IUseMenuComponentProps['focusedValue'];
   isSelected?: boolean;
 };
 
-const Item = ({ item, getItemProps, focusedValue, isSelected }: MenuItemProps) => {
-  const itemProps = getItemProps({ item });
+const Item = ({ item, getAnchorProps, getItemProps, focusedValue, isSelected }: MenuItemProps) => {
+  const itemProps = getItemProps<HTMLLIElement>({ item });
+  const anchorProps = getAnchorProps({ item });
 
   const itemChildren = (
     <>
       <span className="inline-flex justify-center items-center w-4">
-        {item?.type === 'radio' && !!isSelected && '•'}
-        {item?.type === 'checkbox' && !!isSelected && '✓'}
+        {!!isSelected && item.type === 'radio' && '•'}
+        {!!isSelected && (item.type === 'checkbox' || !!item.href) && '✓'}
       </span>
       {item.label || item.value}
     </>
@@ -54,16 +56,21 @@ const Item = ({ item, getItemProps, focusedValue, isSelected }: MenuItemProps) =
         'cursor-pointer': !item.disabled,
         'cursor-default': item.disabled
       })}
-      role={itemProps.href ? 'none' : undefined}
-      {...(!itemProps.href && (itemProps as LiHTMLAttributes<HTMLLIElement>))}
+      {...itemProps}
     >
-      {itemProps.href ? (
+      {anchorProps ? (
         <a
-          {...(itemProps as AnchorHTMLAttributes<HTMLAnchorElement>)}
-          className="w-full rounded-sm outline-offset-0 transition-none border-width-none"
+          {...anchorProps}
+          className={classNames(
+            ' w-full rounded-sm outline-offset-0 transition-none border-width-none',
+            {
+              'text-grey-400': item.disabled,
+              'cursor-default': item.disabled
+            }
+          )}
         >
           {itemChildren}
-          {!!item.isExternal && (
+          {anchorProps.target === '_blank' && (
             <>
               <span aria-hidden="true"> ↗</span>
               <span className="sr-only">(opens in new window)</span>
@@ -85,11 +92,20 @@ const Component = ({
   getTriggerProps,
   getMenuProps,
   getItemProps,
+  getAnchorProps,
   getItemGroupProps,
   getSeparatorProps
 }: MenuReturnValue & UseMenuProps) => {
   const selectedValues = selection.map(item => item.value);
 
+  useEffect(() => {
+    const originalWindowOpen = window.open;
+    window.open = () => null;
+    return () => {
+      window.open = originalWindowOpen;
+    };
+  }, []);
+
   return (
     <div className="relative">
       <button className="px-2 py-1" type="button" {...getTriggerProps()}>
@@ -116,6 +132,7 @@ const Component = ({
                       key={groupItem.value}
                       item={{ ...groupItem }}
                       getItemProps={getItemProps}
+                      getAnchorProps={getAnchorProps}
                       focusedValue={focusedValue}
                       isSelected={selectedValues.includes(groupItem.value)}
                     />
@@ -141,6 +158,8 @@ const Component = ({
               item={item}
               focusedValue={focusedValue}
               getItemProps={getItemProps}
+              getAnchorProps={getAnchorProps}
+              isSelected={selectedValues.includes(item.value)}
             />
           );
         })}
diff --git a/packages/menu/demo/stories/data.ts b/packages/menu/demo/stories/data.ts
index deb6bce22..8e14c7e4a 100644
--- a/packages/menu/demo/stories/data.ts
+++ b/packages/menu/demo/stories/data.ts
@@ -16,9 +16,16 @@ export const ITEMS: MenuItem[] = [
     value: 'plant-04',
     label: 'Aloe Vera',
     href: 'https://en.wikipedia.org/wiki/Aloe_vera',
-    isExternal: false
+    external: false
   },
-  { value: 'plant-05', label: 'Succulent' },
+  {
+    value: 'plant-05',
+    label: 'Palm tree',
+    href: 'https://en.wikipedia.org/wiki/Palm_tree',
+    external: true,
+    disabled: true
+  },
+  { value: 'plant-06', label: 'Succulent' },
   {
     label: 'Choose favorites',
     items: [
diff --git a/packages/menu/src/MenuContainer.spec.tsx b/packages/menu/src/MenuContainer.spec.tsx
index 427f195ba..748a2acfa 100644
--- a/packages/menu/src/MenuContainer.spec.tsx
+++ b/packages/menu/src/MenuContainer.spec.tsx
@@ -6,7 +6,7 @@
  */
 
 import React, { useCallback, useRef, useState } from 'react';
-import { RenderResult, render, act, waitFor } from '@testing-library/react';
+import { act, createEvent, fireEvent, render, RenderResult, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { MenuItem, IMenuItemBase, IUseMenuProps, IUseMenuReturnValue } from './types';
 import { MenuContainer } from './';
@@ -62,11 +62,12 @@ describe('MenuContainer', () => {
       <MenuContainer triggerRef={triggerRef} menuRef={menuRef} {...props}>
         {({
           isExpanded,
-          getSeparatorProps,
+          getAnchorProps,
           getItemGroupProps,
-          getTriggerProps,
+          getItemProps,
           getMenuProps,
-          getItemProps
+          getSeparatorProps,
+          getTriggerProps
         }: IUseMenuReturnValue) => (
           <>
             <button {...getTriggerProps({ disabled })} data-test-id="trigger">
@@ -95,13 +96,22 @@ describe('MenuContainer', () => {
                   return <li {...getSeparatorProps()} key={item.value} data-test-id="separator" />;
                 }
 
+                const anchorProps = getAnchorProps({ item });
+                const itemChildren = item.label || item.value;
+
                 return (
                   <li
                     {...getItemProps({ item })}
                     key={item.value}
-                    data-test-id={`item-${item.label}`}
+                    data-test-id={`item-${itemChildren}`}
                   >
-                    {item.label || item.value}
+                    {anchorProps ? (
+                      <a data-test-id={`item-link-${itemChildren}`} {...anchorProps}>
+                        {itemChildren}
+                      </a>
+                    ) : (
+                      itemChildren
+                    )}
                   </li>
                 );
               })}
@@ -283,14 +293,107 @@ describe('MenuContainer', () => {
       expect(menu).not.toBeVisible();
     });
 
-    it('applies external anchor attributes', () => {
-      const { getByTestId } = render(
-        <TestMenu items={[{ value: 'item', href: '#0', isExternal: true }]} />
-      );
-      const menu = getByTestId('menu');
+    describe('navigational menu items (links)', () => {
+      it('applies href and external anchor attributes, only when not disabled', () => {
+        const { getByText } = render(
+          <TestMenu
+            items={[
+              { value: 'link-1', href: '#1', external: true },
+              { value: 'link-2', href: '#2', external: true, disabled: true }
+            ]}
+          />
+        );
+        const firstLink = getByText('link-1');
+        const secondLink = getByText('link-2');
+
+        expect(firstLink).toHaveAttribute('href', '#1');
+        expect(firstLink).toHaveAttribute('target', '_blank');
+        expect(firstLink).toHaveAttribute('rel', 'noopener noreferrer');
+
+        expect(secondLink).not.toHaveAttribute('href');
+        expect(secondLink).not.toHaveAttribute('target', '_blank');
+        expect(secondLink).not.toHaveAttribute('rel', 'noopener noreferrer');
+      });
+
+      it('applies role="none" to the list item if it contains an anchor', () => {
+        const { getByText, getByTestId } = render(
+          <TestMenu items={[{ value: 'link-1', href: '#1' }]} />
+        );
+        const item = getByTestId('item-link-1');
+        const link = getByText('link-1');
+
+        expect(item).toHaveAttribute('role', 'none');
+
+        expect(link).toHaveAttribute('href', '#1');
+        expect(link).not.toHaveAttribute('target');
+      });
+
+      it('tracks click events on links and alls the onChange function with the correct parameters', async () => {
+        const onChangeSpy = jest.fn();
+
+        const { getByTestId, getByText } = render(
+          <TestMenu
+            items={[
+              { value: 'link-1', href: '#1' },
+              { value: 'link-2', href: '#2' }
+            ]}
+            onChange={onChangeSpy}
+          />
+        );
+        const trigger = getByTestId('trigger');
+        const link = getByText('link-2');
+
+        await waitFor(async () => {
+          await user.click(trigger);
+          await user.click(link);
+        });
+
+        expect(onChangeSpy.mock.calls[2][0]).toStrictEqual({
+          type: 'menuItem:click',
+          value: 'link-2',
+          isExpanded: false,
+          selectedItems: []
+        });
+
+        expect(link).not.toHaveAttribute('aria-current', 'page');
+      });
+
+      it('supports setting the selected link via item.selected and ignore link selection changes', async () => {
+        const onChangeSpy = jest.fn();
+        const { getByTestId, getByText } = render(
+          <TestMenu
+            items={[
+              { value: 'link-1', href: '#1' },
+              { value: 'link-2', href: '#2', selected: true }
+            ]}
+            onChange={onChangeSpy}
+          />
+        );
+        const trigger = getByTestId('trigger');
+        const secondLink = getByText('link-2');
+
+        await waitFor(async () => {
+          await user.click(trigger);
+        });
+
+        expect(secondLink).toHaveAttribute('aria-current', 'page');
+
+        const firstLink = getByText('link-1');
+
+        await waitFor(async () => {
+          await user.click(trigger);
+          await user.click(firstLink);
+        });
+
+        expect(onChangeSpy.mock.calls[3][0]).toStrictEqual({
+          type: 'menuItem:click',
+          value: 'link-1',
+          isExpanded: false,
+          selectedItems: [{ href: '#2', selected: true, value: 'link-2' }]
+        });
 
-      expect(menu.firstChild).toHaveAttribute('target', '_blank');
-      expect(menu.firstChild).toHaveAttribute('rel', 'noopener noreferrer');
+        expect(firstLink).not.toHaveAttribute('aria-current');
+      });
     });
 
     describe('focus', () => {
@@ -1265,6 +1368,66 @@ describe('MenuContainer', () => {
         expect(changeTypes).toContain(StateChangeTypes.MenuItemKeyDownPrevious);
       });
     });
+
+    describe('navigational menu items (links)', () => {
+      it('applies the correct aria-current attribute to user-selected link', async () => {
+        const { getByTestId, getByText } = render(
+          <TestMenu
+            items={[
+              { value: 'link-1', href: '#1' },
+              { value: 'link-2', href: '#2' }
+            ]}
+            selectedItems={[{ value: 'link-2' }]}
+          />
+        );
+        const trigger = getByTestId('trigger');
+        const link = getByText('link-2');
+
+        await waitFor(async () => {
+          await user.click(trigger);
+        });
+
+        expect(link).toHaveAttribute('aria-current', 'page');
+      });
+
+      it('prevents default only when clicking on user-selected link', async () => {
+        const { getByTestId, getByText } = render(
+          <TestMenu
+            items={[
+              { value: 'link-1', href: '#1' },
+              { value: 'link-2', href: '#2' }
+            ]}
+            selectedItems={[{ value: 'link-2' }]}
+          />
+        );
+        const trigger = getByTestId('trigger');
+        const firstLink = getByText('link-1');
+        const secondLink = getByText('link-2');
+
+        await waitFor(async () => {
+          await user.click(trigger);
+          await user.click(firstLink);
+        });
+
+        expect(firstLink).not.toHaveAttribute('aria-current');
+
+        const firstLinkClickEvent = createEvent.click(firstLink);
+        firstLinkClickEvent.preventDefault = jest.fn();
+        fireEvent(firstLink, firstLinkClickEvent);
+
+        // fire click event one more time to test behavior on previously clicked anchor
+        fireEvent(firstLink, firstLinkClickEvent);
+
+        expect(firstLinkClickEvent.preventDefault).toHaveBeenCalledTimes(0);
+
+        const secondLinkClickEvent = createEvent.click(secondLink);
+        secondLinkClickEvent.preventDefault = jest.fn();
+        fireEvent(secondLink, secondLinkClickEvent);
+
+        expect(secondLinkClickEvent.preventDefault).toHaveBeenCalledTimes(1);
+        expect(secondLink).toHaveAttribute('aria-current', 'page');
+      });
+    });
   });
 
   describe('error handling', () => {
diff --git a/packages/menu/src/types.ts b/packages/menu/src/types.ts
index d3826403d..21eb5ed96 100644
--- a/packages/menu/src/types.ts
+++ b/packages/menu/src/types.ts
@@ -5,7 +5,7 @@
  * found at http://www.apache.org/licenses/LICENSE-2.0.
  */
 
-import { ButtonHTMLAttributes, HTMLProps, ReactNode, RefObject } from 'react';
+import { AnchorHTMLAttributes, ButtonHTMLAttributes, HTMLProps, ReactNode, RefObject } from 'react';
 
 export interface ISelectedItem {
   value: string;
@@ -14,7 +14,7 @@ export interface ISelectedItem {
   type?: 'radio' | 'checkbox';
   disabled?: boolean;
   href?: string;
-  isExternal?: boolean;
+  external?: boolean;
 }
 
 export interface IMenuItemBase extends ISelectedItem {
@@ -42,8 +42,10 @@ export interface IUseMenuProps<T = HTMLButtonElement, M = HTMLElement> {
    * @param {string} item.value Unique item value
    * @param {string} item.label Optional human-readable text value (defaults to `item.value`)
    * @param {string} item.name A shared name corresponding to an item radio group
+   * @param {string} item.href The URL to navigate to when the link item is clicked
+   * @param {boolean} item.external Indicates that link item is an external link
    * @param {boolean} item.disabled Indicates the item is not interactive
-   * @param {boolean} item.selected Sets initial selection for the option
+   * @param {boolean} item.selected Sets initial selection for the option. The initial selection persists for link items.
    * @param {boolean} item.isNext - Indicates the item transitions to a nested menu
    * @param {boolean} item.isPrevious - Indicates the item will transition back from a nested menu
    * @param {boolean} item.separator Indicates the item is a placeholder for a separator
@@ -114,9 +116,16 @@ export interface IUseMenuReturnValue {
   getItemProps: <T extends Element>(
     props: Omit<HTMLProps<T>, 'role'> & {
       item: IMenuItemBase;
-      role?: 'menuitem' | 'menuitemradio' | 'menuitemcheckbox' | null;
+      role?: 'menuitem' | 'menuitemradio' | 'menuitemcheckbox' | 'none' | null;
     }
   ) => HTMLProps<T>;
+  getAnchorProps: (
+    props: Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'role'> & {
+      item: IMenuItemBase;
+      role?: 'link' | null;
+    }
+  ) => AnchorHTMLAttributes<HTMLAnchorElement> | undefined;
+
   getSeparatorProps: <T extends Element>(
     props?: HTMLProps<T> & {
       role?: 'separator' | 'none' | null;
@@ -131,6 +140,7 @@ export interface IMenuContainerProps<T = HTMLElement, M = HTMLElement> extends I
    * @param {function} [options.getTriggerProps] Trigger props getter
    * @param {function} [options.getMenuProps] Menu props getter
    * @param {function} [options.getItemProps] Menu item props getter
+   * @param {function} [options.getAnchorProps] Menu link item props getter
    * @param {function} [options.getSeparatorProps] Separator item props getter
    * @param {boolean} [options.isExpanded] Current menu expansion
    * @param {ISelectedItem[]} [options.selection] Current selection
@@ -141,6 +151,7 @@ export interface IMenuContainerProps<T = HTMLElement, M = HTMLElement> extends I
     getTriggerProps: IUseMenuReturnValue['getTriggerProps'];
     getMenuProps: IUseMenuReturnValue['getMenuProps'];
     getItemProps: IUseMenuReturnValue['getItemProps'];
+    getAnchorProps: IUseMenuReturnValue['getAnchorProps'];
     getSeparatorProps: IUseMenuReturnValue['getSeparatorProps'];
     /* state */
     isExpanded: IUseMenuReturnValue['isExpanded'];
diff --git a/packages/menu/src/useMenu.ts b/packages/menu/src/useMenu.ts
index c52dad233..3751e4e87 100644
--- a/packages/menu/src/useMenu.ts
+++ b/packages/menu/src/useMenu.ts
@@ -34,7 +34,6 @@ import {
   IMenuItemBase,
   IUseMenuProps,
   IUseMenuReturnValue,
-  IMenuItemGroup,
   ISelectedItem
 } from './types';
 
@@ -60,22 +59,27 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
   const isFocusedValueControlled = focusedValue !== undefined;
   const menuItems = useMemo(
     () =>
-      rawItems.reduce((items, item: MenuItem) => {
+      rawItems.reduce<IMenuItemBase[]>((items, item: MenuItem) => {
         if (isItemGroup(item)) {
-          items.push(...((item as IMenuItemGroup).items.filter(isValidItem) as IMenuItemBase[]));
+          const nestedItems = item.items.filter(isValidItem);
+
+          items.push(...nestedItems);
         } else if (isValidItem(item)) {
-          items.push(item as IMenuItemBase);
+          items.push(item);
         }
 
         return items;
-      }, [] as IMenuItemBase[]),
+      }, []),
     [rawItems]
   );
   const initialSelectedItems = useMemo(
     () =>
-      menuItems.filter(
-        item => !!(item.type && ['radio', 'checkbox'].includes(item.type) && item.selected)
-      ),
+      menuItems.filter(item => {
+        return !!(
+          (item.href || item.type === 'radio' || item.type === 'checkbox') &&
+          item.selected
+        );
+      }),
     [menuItems]
   );
   const values = useMemo(() => menuItems.map(item => item.value), [menuItems]);
@@ -155,7 +159,7 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
   );
 
   const isItemSelected = useCallback(
-    (value: string, type?: string, name?: string): boolean | undefined => {
+    (value: string, type?: string, name?: string, href?: string): boolean | undefined => {
       let isSelected;
 
       if (type === 'checkbox') {
@@ -163,6 +167,10 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
       } else if (type === 'radio') {
         const match = controlledSelectedItems.filter(item => item.name === name)[0];
 
+        isSelected = match?.value === value;
+      } else if (href) {
+        const match = controlledSelectedItems.filter(item => item.value === value)[0];
+
         isSelected = match?.value === value;
       }
 
@@ -218,11 +226,12 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
   );
 
   const getSelectedItems = useCallback(
-    ({ value, type, name, label, selected }: IMenuItemBase) => {
-      let changes: ISelectedItem[] | null = [...controlledSelectedItems];
-
+    ({ value, type, name, label, selected, href }: IMenuItemBase) => {
+      if (href) return controlledSelectedItems;
       if (!type) return null;
 
+      let changes: ISelectedItem[] | null = [...controlledSelectedItems];
+
       const selectedItem = {
         value,
         type,
@@ -428,15 +437,17 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
   }, [onChange]);
 
   const handleItemClick = useCallback(
-    (item: IMenuItemBase) => {
+    (event: React.MouseEvent, item: IMenuItemBase) => {
       let changeType = StateChangeTypes.MenuItemClick;
-      const { isNext, isPrevious } = item;
+      const { isNext, isPrevious, href, selected } = item;
       const isTransitionItem = isNext || isPrevious;
 
       if (isNext) {
         changeType = StateChangeTypes.MenuItemClickNext;
       } else if (isPrevious) {
         changeType = StateChangeTypes.MenuItemClickPrevious;
+      } else if (href && selected) {
+        event.preventDefault();
       }
 
       const nextSelection = getSelectedItems(item);
@@ -802,13 +813,35 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
         name,
         value,
         href,
-        isExternal,
         isNext = false,
         isPrevious = false,
         label = value
       } = item;
       let itemRole = role;
 
+      const baseAttributes = {
+        'data-garden-container-id': 'containers.menu.item',
+        'data-garden-container-version': PACKAGE_VERSION,
+        onClick,
+        onKeyDown,
+        onMouseEnter
+      };
+
+      if (href) {
+        /**
+         * Validation
+         */
+        if (isNext || isPrevious || type) {
+          anchorItemError(item);
+        }
+
+        return {
+          ...baseAttributes,
+          role: itemRole === null ? undefined : 'none',
+          ...other
+        };
+      }
+
       if (type === 'radio') {
         itemRole = 'menuitemradio';
       } else if (type === 'checkbox') {
@@ -826,30 +859,93 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
        * by useSelection.
        */
       const elementProps = {
-        'data-garden-container-id': 'containers.menu.item',
-        'data-garden-container-version': PACKAGE_VERSION,
+        ...baseAttributes,
         'aria-selected': undefined,
+        'aria-disabled': itemRole === 'none' ? undefined : itemDisabled,
         'aria-checked': selected,
-        'aria-disabled': itemDisabled,
         role: itemRole === null ? undefined : itemRole,
-        href,
+        ...other
+      };
+
+      if (itemDisabled) {
+        return elementProps;
+      }
+
+      const itemProps = getElementProps({
+        value: value as any,
+        ...elementProps,
+        onClick: composeEventHandlers(onClick, (e: React.MouseEvent) =>
+          handleItemClick(e, { ...item, label, selected, isNext, isPrevious })
+        ),
+        onKeyDown: composeEventHandlers(onKeyDown, (e: React.KeyboardEvent) =>
+          handleItemKeyDown(e, { ...item, label, selected, isNext, isPrevious })
+        ),
+        onMouseEnter: composeEventHandlers(onMouseEnter, () => handleItemMouseEnter(value))
+      });
+
+      if (itemProps.ref !== itemRefs[value]) {
+        itemRefs[value] = itemProps.ref as RefObject<any>;
+      }
+
+      return itemProps;
+    },
+    [
+      itemRefs,
+      isItemSelected,
+      getElementProps,
+      handleItemClick,
+      handleItemKeyDown,
+      handleItemMouseEnter
+    ]
+  );
+
+  const getAnchorProps = useCallback<IUseMenuReturnValue['getAnchorProps']>(
+    ({ role = 'menuitem', onClick, onKeyDown, onMouseEnter, item, ...other }) => {
+      const { disabled: itemDisabled, value, href, external, label = value } = item;
+
+      if (!href) return undefined;
+
+      /**
+       * The "select" of useSelection isn't
+       * leveraged in useMenu, so `aria-selected` attribute
+       * is intentionally `undefined` in all cases.
+       *
+       * Instead, `aria-current` is used, but not managed
+       * by useSelection.
+       */
+      const elementProps = {
+        'data-garden-container-id': 'containers.menu.item.link',
+        'data-garden-container-version': PACKAGE_VERSION,
+        'aria-disabled': itemDisabled,
+        'aria-selected': undefined,
+        role: role === null ? undefined : role,
         onClick,
         onKeyDown,
         onMouseEnter,
         ...other
       };
 
-      if (href && isExternal) {
-        elementProps.target = '_blank';
-        elementProps.rel = 'noopener noreferrer';
-      }
+      const selected = isItemSelected(value, undefined, undefined, href);
 
       /**
-       * Validation
+       * For a disabled link to be valid, it must have:
+       *  - `aria-disabled="true"`
+       *  - `role="link"`, or `role="menuitem"` if within a menu
+       *  - an `undefined` `href`
+       *
+       * @see https://www.scottohara.me/blog/2021/05/28/disabled-links.html
        */
+      if (!itemDisabled) {
+        elementProps.href = href;
+
+        if (external) {
+          elementProps.target = '_blank';
+          elementProps.rel = 'noopener noreferrer';
+        }
 
-      if (href && (isNext || isPrevious || type)) {
-        anchorItemError(item);
+        if (selected) {
+          elementProps['aria-current'] = 'page';
+        }
       }
 
       if (itemDisabled) {
@@ -859,11 +955,11 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
       const itemProps = getElementProps({
         value: value as any,
         ...elementProps,
-        onClick: composeEventHandlers(onClick, () =>
-          handleItemClick({ ...item, label, selected, isNext, isPrevious })
+        onClick: composeEventHandlers(onClick, (e: React.MouseEvent) =>
+          handleItemClick(e, { ...item, label, selected })
         ),
         onKeyDown: composeEventHandlers(onKeyDown, (e: React.KeyboardEvent) =>
-          handleItemKeyDown(e, { ...item, label, selected, isNext, isPrevious })
+          handleItemKeyDown(e, { ...item, label, selected })
         ),
         onMouseEnter: composeEventHandlers(onMouseEnter, () => handleItemMouseEnter(value))
       });
@@ -887,25 +983,27 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
   return useMemo(
     () => ({
       /* prop getters */
-      getTriggerProps,
-      getMenuProps,
+      getAnchorProps,
       getItemGroupProps,
       getItemProps,
+      getMenuProps,
       getSeparatorProps,
+      getTriggerProps,
       /* state */
       isExpanded: controlledIsExpanded!,
       selection: controlledSelectedItems,
       focusedValue: controlledFocusedValue
     }),
     [
+      controlledFocusedValue,
       controlledIsExpanded,
       controlledSelectedItems,
-      controlledFocusedValue,
-      getTriggerProps,
-      getMenuProps,
+      getAnchorProps,
       getItemGroupProps,
       getItemProps,
-      getSeparatorProps
+      getMenuProps,
+      getSeparatorProps,
+      getTriggerProps
     ]
   );
 };
diff --git a/packages/menu/src/utils.ts b/packages/menu/src/utils.ts
index a395ab6f8..123a167b8 100644
--- a/packages/menu/src/utils.ts
+++ b/packages/menu/src/utils.ts
@@ -7,7 +7,13 @@
 
 import { Reducer } from 'react';
 import { KEYS } from '@zendeskgarden/container-utilities';
-import { MenuItem, IMenuItemBase, IMenuItemSeparator, ISelectedItem } from './types';
+import {
+  MenuItem,
+  IMenuItemBase,
+  IMenuItemSeparator,
+  ISelectedItem,
+  IMenuItemGroup
+} from './types';
 
 export const triggerLink = (element: HTMLAnchorElement, view: Window) => {
   const event = new MouseEvent('click', {
@@ -46,9 +52,9 @@ export const StateChangeTypes: Record<string, string> = {
   MenuItemKeyDownEnd: `menuItem:keyDown:${KEYS.END}`
 };
 
-export const isItemGroup = (item: MenuItem) => Object.hasOwn(item, 'items');
+export const isItemGroup = (item: MenuItem): item is IMenuItemGroup => Object.hasOwn(item, 'items');
 
-export const isValidItem = (item: MenuItem) =>
+export const isValidItem = (item: MenuItem): item is IMenuItemBase =>
   !(item as IMenuItemBase).disabled &&
   !(item as IMenuItemSeparator).separator &&
   !isItemGroup(item);