@astryxdesign/core 0.6.2 → 0.6.3-canary.0899f21

package/src/BottomSheet/BottomSheetPanel.tsx

@@ -4,14 +4,14 @@
 
 /**
  * @file BottomSheetPanel.tsx
- * @input Uses React, StyleX, theme tokens, useSheetGestures
- * @output Internal BottomSheetPanel surface and motion-state types
+ * @input Uses React, StyleX, theme tokens, sheet gestures, shared scroll behavior, and the host label
+ * @output Internal BottomSheetPanel with a keyboard-reachable scrolling body and motion-state types
  * @position Shared presentation layer for standalone and switcher BottomSheets
  *
  * This component owns everything intrinsic to a sheet surface: height budgets,
  * drag and snap gestures, the handle and scrolling body, motion styles, and
- * transition completion. It deliberately does not own a dialog, focus, inert
- * state, or switcher registration; those belong to the hosting controller.
+ * transition completion. It owns the body's keyboard access; dialog focus
+ * entry/return, inert state, and switcher registration belong to the host.
  *
  * SYNC: When modified, update these files to stay in sync:
  * - /packages/core/src/BottomSheet/BottomSheet.tsx
@@ -33,17 +33,20 @@ import {
 import * as stylex from '@stylexjs/stylex';
 import type {BaseProps} from '../BaseProps';
 import {useDevWarning} from '../hooks';
+import {useScrollableArea} from '../hooks/useScrollableArea';
 import {
   borderVars,
   colorVars,
   durationVars,
   easeVars,
+  focusVars,
   radiusVars,
   shadowVars,
   sizeVars,
   spacingVars,
 } from '../theme/tokens.stylex';
 import {mergeProps, themeProps} from '../utils';
+import {focusOutlineStyles} from '../utils/focusOutline.stylex';
 import {overlayPaddingReset} from '../Layout/padding.stylex';
 import {
   isValidSnapPoint,
@@ -211,9 +214,11 @@ const styles = stylex.create({
     flexGrow: 1,
     minHeight: 0,
     boxSizing: 'border-box',
-    overflowY: 'auto',
-    overscrollBehavior: 'none',
     touchAction: 'pan-y',
+    outlineOffset: {
+      default: 0,
+      ':focus-visible': `calc(-1 * ${focusVars['--focus-outline-width']})`,
+    },
     // The scrolling area paints the surface itself, covering the sheet's whole
     // inner box. Without it the sheet's edge is not uniform: a theme that packs
     // an inset ring into --shadow-high (the bundled themes all add one in dark
@@ -229,6 +234,15 @@ const styles = stylex.create({
     // space a content wrapper's own top padding already provides.
     paddingBlockEnd: 0,
   },
+  content: {
+    // Preserve the body's block formatting (including margin/float isolation)
+    // and its definite percentage-height basis. min-content lets this real
+    // observed box grow with async content beyond a fixed-height viewport.
+    display: 'flow-root',
+    boxSizing: 'border-box',
+    height: '100%',
+    minHeight: 'min-content',
+  },
   tallKeyboardBody: {
     scrollPaddingBlockEnd: MOBILE_KEYBOARD_BOTTOM_CLEARANCE,
     '::after': {
@@ -265,6 +279,8 @@ interface BottomSheetPanelProps extends BaseProps<HTMLDivElement> {
   ref?: React.Ref<HTMLDivElement>;
   state: BottomSheetPanelState;
   height: BottomSheetHeight | number | string;
+  /** Existing host name, reused for the keyboard scrolling group. */
+  label: string;
   children: ReactNode;
   snapPoints?: ReadonlyArray<BottomSheetSnapPoint>;
   isSwipeDismissAllowed?: boolean;
@@ -391,6 +407,7 @@ export function BottomSheetPanel({
   ref,
   state,
   height,
+  label,
   children,
   snapPoints,
   className,
@@ -490,6 +507,17 @@ export function BottomSheetPanel({
     onScrimOpacity,
   });
 
+  const {getViewportProps, getContentProps} = useScrollableArea({
+    // The previous overflow-y:auto also computed overflow-x:auto. Keep wide
+    // content reachable instead of clipping that existing inline scroll path.
+    axis: 'both',
+    keyboardAccess: {owner: 'contentOrViewport', label},
+    overscroll: 'contain',
+    // The sheet body deliberately remains the boundary for sheet-local sticky
+    // content while fitting, as it was before shared scroll adoption.
+    stickyContainment: 'always',
+  });
+
   const setElement = useCallback(
     (element: HTMLDivElement | null) => {
       sheetRef(element);
@@ -656,17 +684,22 @@ export function BottomSheetPanel({
         <div {...stylex.props(styles.handlePill)} />
       </div>
       <div
-        {...mergeProps(
-          stylex.props(
-            styles.body,
-            height === 'tall' && styles.tallKeyboardBody,
+        {...getViewportProps<HTMLDivElement>({
+          ...bodyProps,
+          ...mergeProps(
+            stylex.props(
+              focusOutlineStyles.focusVisible,
+              styles.body,
+              height === 'tall' && styles.tallKeyboardBody,
+            ),
+            scrollPreservationInset > 0
+              ? {style: {paddingBlockEnd: `${scrollPreservationInset}px`}}
+              : {},
           ),
-          scrollPreservationInset > 0
-            ? {style: {paddingBlockEnd: `${scrollPreservationInset}px`}}
-            : {},
-        )}
-        {...bodyProps}>
-        {children}
+        })}>
+        <div {...getContentProps<HTMLDivElement>(stylex.props(styles.content))}>
+          {children}
+        </div>
       </div>
     </div>
   );

package/src/BottomSheet/__tests__/BottomSheetKeyboard.a11y.browser.spec.ts

@@ -0,0 +1,344 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file BottomSheetKeyboard.a11y.browser.spec.ts
+ * @input Built BottomSheet stories and real Chromium/WebKit keyboard input
+ * @output Browser evidence for shared focus delegation, traversal, and native scrolling
+ * @position Cross-browser proof for useScrollableArea's contentOrViewport policy
+ */
+
+import {expect, test, type Page, type Locator} from '@playwright/test';
+import {
+  DEFAULT_STORYBOOK_DIR,
+  serveStorybook,
+  type StaticServer,
+} from '@astryxdesign/a11y-spec/storybook';
+
+let storybook: StaticServer;
+test.beforeAll(async () => {
+  storybook = await serveStorybook(
+    process.env.ASTRYX_STORYBOOK_DIR ?? DEFAULT_STORYBOOK_DIR,
+  );
+});
+test.afterAll(async () => {
+  await storybook?.close();
+});
+
+// macOS WebKit defaults to text-field traversal. Option+Tab selects its native
+// all-controls traversal, equivalent to enabling Safari's keyboard preference.
+function tabKey(browserName: string, reverse = false): string {
+  return `${browserName === 'webkit' && process.platform === 'darwin' ? 'Alt+' : ''}${reverse ? 'Shift+' : ''}Tab`;
+}
+
+async function mount(page: Page, browserName: string, variant = 'button') {
+  await page.goto(
+    `${storybook.origin}/iframe.html?id=core-bottomsheet--keyboard-delegation&viewMode=story`,
+  );
+  const viewport = page.getByRole('group', {
+    name: 'Keyboard reading',
+    exact: true,
+  });
+  await expect(viewport).toHaveAttribute('data-scrollable-block', 'true');
+  await page.getByLabel('Content case').selectOption(variant);
+  await expect(viewport).toHaveAttribute('tabindex', '0');
+  // WebKit includes the non-modal dialog host in sequential navigation;
+  // Chromium enters its descendants directly. Start immediately before the body.
+  const before =
+    browserName === 'webkit'
+      ? page.getByRole('dialog', {name: 'Keyboard reading', exact: true})
+      : page.getByRole('button', {name: 'Toggle modal', exact: true});
+  await before.focus();
+  return {viewport, before};
+}
+
+for (const variant of ['button', 'link']) {
+  test(`${variant}: forward entry delegates once and reverse traversal exits`, async ({
+    page,
+    browserName,
+  }) => {
+    const {viewport, before} = await mount(page, browserName, variant);
+    const first = page.getByRole(variant === 'button' ? 'button' : 'link', {
+      name: variant === 'button' ? 'First action' : 'First link',
+      exact: true,
+    });
+    await page.keyboard.press(tabKey(browserName));
+    await expect(first).toBeFocused();
+    await expect(viewport).toHaveAttribute('tabindex', '0');
+    await expect(viewport).toHaveAccessibleName('Keyboard reading');
+    await expect(first).toHaveAccessibleName(
+      variant === 'button' ? 'First action' : 'First link',
+    );
+    await page.keyboard.press(tabKey(browserName));
+    await expect(page.getByRole('button', {name: 'Last action'})).toBeFocused();
+    await page.keyboard.press(tabKey(browserName, true));
+    await expect(first).toBeFocused();
+    await page.keyboard.press(tabKey(browserName, true));
+    await expect(before).toBeFocused();
+    await expect(viewport).toHaveAttribute('tabindex', '0');
+    await page.keyboard.press(tabKey(browserName));
+    await expect(first).toBeFocused();
+  });
+}
+
+for (const variant of [
+  'text',
+  'input',
+  'disabled',
+  'nested',
+  'native-scroll',
+  'radiogroup',
+  'slider',
+  'combobox',
+  'listbox',
+  'menu',
+  'grid',
+  'tree',
+  'tablist',
+  'toolbar',
+]) {
+  test(`${variant}: retains a named viewport stop`, async ({
+    page,
+    browserName,
+  }) => {
+    const {viewport, before} = await mount(page, browserName, variant);
+    await page.keyboard.press(tabKey(browserName));
+    await expect(viewport).toBeFocused();
+    await expect(viewport).toHaveAccessibleName('Keyboard reading');
+    await page.keyboard.press(tabKey(browserName, true));
+    await expect(before).toBeFocused();
+  });
+}
+
+async function scrollRange(viewport: Locator) {
+  return viewport.evaluate(element => ({
+    position: element.scrollTop,
+    max: element.scrollHeight - element.clientHeight,
+  }));
+}
+
+for (const key of ['PageDown', 'ArrowDown']) {
+  test(`${key}: reaches both scroll edges after delegation`, async ({
+    page,
+    browserName,
+  }) => {
+    const {viewport} = await mount(page, browserName);
+    await page.keyboard.press(tabKey(browserName));
+    const first = page.getByRole('button', {name: 'First action', exact: true});
+    await expect(first).toBeFocused();
+    for (let count = 0; count < 300; count++) {
+      const {position, max} = await scrollRange(viewport);
+      if (position >= max - 1) {
+        break;
+      }
+      await page.keyboard.press(key, {delay: key === 'ArrowDown' ? 50 : 25});
+    }
+    await expect
+      .poll(async () => {
+        const {position, max} = await scrollRange(viewport);
+        // WebKit can overshoot a native edge while showing rubber-band feedback.
+        return max - position;
+      })
+      .toBeLessThanOrEqual(1);
+    for (let count = 0; count < 300; count++) {
+      if ((await scrollRange(viewport)).position <= 1) {
+        break;
+      }
+      await page.keyboard.press(key === 'PageDown' ? 'PageUp' : 'ArrowUp', {
+        delay: key === 'ArrowDown' ? 50 : 25,
+      });
+    }
+    await expect
+      .poll(async () => (await scrollRange(viewport)).position)
+      .toBeLessThanOrEqual(1);
+    await expect(first).toBeFocused();
+  });
+}
+
+test('pointer and programmatic focus stay on the viewport, including during keydown', async ({
+  page,
+  browserName,
+}) => {
+  const {viewport, before} = await mount(page, browserName);
+  await viewport.focus();
+  await expect(viewport).toBeFocused();
+  await before.focus();
+  await viewport.click({position: {x: 4, y: 40}});
+  await expect(viewport).toBeFocused();
+  await before.focus();
+  await before.evaluate(element => {
+    element.addEventListener('keydown', event => {
+      if (event instanceof KeyboardEvent && event.key === 'Tab') {
+        event.preventDefault();
+        document
+          .querySelector<HTMLElement>(
+            '[role="group"][aria-label="Keyboard reading"]',
+          )
+          ?.focus();
+      }
+    });
+  });
+  await page.keyboard.press(tabKey(browserName));
+  await expect(viewport).toBeFocused();
+});
+
+test('dynamic eligibility is checked at the next entry without mutation observation', async ({
+  page,
+  browserName,
+}) => {
+  await page.addInitScript(() => {
+    const Original = window.MutationObserver;
+    const observers: MutationObserver[] = [];
+    window.MutationObserver = class extends Original {
+      constructor(callback: MutationCallback) {
+        super(callback);
+        observers.push(this);
+      }
+    };
+    Object.assign(window, {
+      stopMutationObservers: () =>
+        observers.forEach(observer => observer.disconnect()),
+    });
+  });
+  const {viewport, before} = await mount(page, browserName);
+  await page.evaluate(() => {
+    (
+      window as unknown as {stopMutationObservers: () => void}
+    ).stopMutationObservers();
+  });
+  await viewport.focus();
+  const first = page.getByRole('button', {name: 'First action', exact: true});
+  await first.evaluate(element => element.setAttribute('disabled', ''));
+  await expect(viewport).toBeFocused();
+  await before.focus();
+  await page.keyboard.press(tabKey(browserName));
+  await expect(page.getByRole('button', {name: 'Last action'})).toBeFocused();
+  await before.focus();
+  await first.evaluate(element => element.removeAttribute('disabled'));
+  await page.keyboard.press(tabKey(browserName));
+  await expect(first).toBeFocused();
+  await before.focus();
+  await viewport.locator('[data-scroll-content]').evaluate(element => {
+    const input = document.createElement('input');
+    input.setAttribute('aria-label', 'Inserted input');
+    element.prepend(input);
+  });
+  await page.keyboard.press(tabKey(browserName));
+  await expect(viewport).toBeFocused();
+  await page.getByLabel('Inserted input').evaluate(element => element.remove());
+  await expect(viewport).toBeFocused();
+  await before.focus();
+  await page.keyboard.press(tabKey(browserName));
+  await expect(first).toBeFocused();
+  await before.focus();
+  await first.evaluate(element => element.setAttribute('role', 'combobox'));
+  await page.keyboard.press(tabKey(browserName));
+  await expect(viewport).toBeFocused();
+});
+
+test('modal BottomSheet keeps native focus containment without cycling through the viewport', async ({
+  page,
+  browserName,
+}) => {
+  await mount(page, browserName);
+  await page.getByRole('button', {name: 'Toggle modal', exact: true}).click();
+  const dialog = page.getByRole('dialog', {
+    name: 'Keyboard reading',
+    exact: true,
+  });
+  await expect
+    .poll(async () => dialog.evaluate(element => element.matches(':modal')))
+    .toBe(true);
+  const viewport = page.getByRole('group', {
+    name: 'Keyboard reading',
+    exact: true,
+  });
+  await expect(viewport).toHaveAttribute('data-scrollable-block', 'true');
+  const panel = dialog.locator('.astryx-bottom-sheet');
+  await panel.focus();
+  await page.keyboard.press(tabKey(browserName));
+  const first = page.getByRole('button', {name: 'First action', exact: true});
+  await expect(first).toBeFocused();
+  await page.keyboard.press(tabKey(browserName, true));
+  await expect(viewport).not.toBeFocused();
+  await expect(first).not.toBeFocused();
+  // Native dialog traversal may wrap to another sheet target or browser chrome;
+  // it must never focus the inert background or create a viewport/child loop.
+  await expect(
+    page.getByRole('button', {name: 'Before sheet', includeHidden: true}),
+  ).not.toBeFocused();
+  await expect(viewport).toHaveAttribute('tabindex', '0');
+});
+
+test('fitting text removes the viewport stop while preserving current focus', async ({
+  page,
+  browserName,
+}) => {
+  const {viewport} = await mount(page, browserName, 'text');
+  await viewport.focus();
+  await viewport.locator('[data-scroll-content]').evaluate(element => {
+    element.textContent = 'Short reading content';
+  });
+  await expect(viewport).not.toHaveAttribute('data-scrollable-block', 'true');
+  await expect(viewport).toHaveAttribute('tabindex', '-1');
+  await expect(viewport).toBeFocused();
+});
+
+test('horizontal overflow remains keyboard scrollable after delegation', async ({
+  page,
+  browserName,
+}) => {
+  const {viewport, before} = await mount(page, browserName);
+  await viewport.evaluate(element => {
+    const content = element.querySelector<HTMLElement>('[data-scroll-content]');
+    if (content != null) {
+      content.style.width = `${element.clientWidth + 320}px`;
+    }
+  });
+  await expect(viewport).toHaveAttribute('data-scrollable-inline', 'true');
+  await before.focus();
+  await page.keyboard.press(tabKey(browserName));
+  await expect(
+    page.getByRole('button', {name: 'First action', exact: true}),
+  ).toBeFocused();
+  for (const key of ['ArrowRight', 'ArrowLeft']) {
+    for (let count = 0; count < 100; count++) {
+      const atEdge = await viewport.evaluate(
+        (element, forward) =>
+          forward
+            ? element.scrollLeft >=
+              element.scrollWidth - element.clientWidth - 1
+            : element.scrollLeft <= 1,
+        key === 'ArrowRight',
+      );
+      if (atEdge) {
+        break;
+      }
+      await page.keyboard.press(key, {delay: 50});
+    }
+    await expect
+      .poll(async () =>
+        viewport.evaluate(
+          (element, forward) =>
+            forward
+              ? element.scrollWidth - element.clientWidth - element.scrollLeft
+              : element.scrollLeft,
+          key === 'ArrowRight',
+        ),
+      )
+      .toBeLessThanOrEqual(1);
+  }
+});
+
+test('does not skip an aria-hidden first tab stop to delegate to a later action', async ({
+  page,
+  browserName,
+}) => {
+  const {viewport} = await mount(page, browserName);
+  await page
+    .getByRole('button', {name: 'First action', exact: true})
+    .evaluate(element => {
+      element.setAttribute('aria-hidden', 'true');
+    });
+  await page.keyboard.press(tabKey(browserName));
+  await expect(viewport).toBeFocused();
+});

package/src/Button/Button.doc.mjs

@@ -157,8 +157,8 @@ export const docs = {
       name: 'icon',
       type: 'ReactNode',
       description:
-        'Icon element rendered before the label text.',
-      slotElements: [{__element: 'Icon', props: {icon: 'check', size: 'sm'}}],
+        'Icon element rendered before the label text. An Astryx Icon with no explicit size defaults to sm for sm/md buttons and md for lg buttons.',
+      slotElements: [{__element: 'Icon', props: {icon: 'check'}}],
     },
     {
       name: 'isIconOnly',
@@ -210,7 +210,7 @@ export const docs = {
       name: 'href',
       type: 'string',
       description:
-        'When provided, renders the button as a link element (<a> or custom link component).',
+        'When provided, renders the button as a link element (<a> or custom link component). The destination follows the shared navigation rule described on the Link `href` prop.',
     },
     {
       name: 'as',
@@ -294,7 +294,7 @@ export const docsZh = {
       description: '禁用按钮。存在工具提示时，使用 aria-disabled 代替原生 disabled 以保持可聚焦。',
       default: 'false',
     },
-    {name: 'icon', type: 'ReactNode', description: '图标元素。仅提供 icon 而不提供 children 时，按钮渲染为正方形的纯图标按钮。'},
+    {name: 'icon', type: 'ReactNode', description: '图标元素。未显式指定尺寸的 Astryx Icon 在 sm/md 按钮中默认为 sm，在 lg 按钮中默认为 md。仅提供 icon 而不提供 children 时，按钮渲染为正方形的纯图标按钮。'},
     {name: 'width', type: 'SizeValue', description: "按钮宽度。数字按像素处理，字符串按原样使用（如 '100%' 表示全宽按钮）。默认按内容自适应宽度。"},
     {name: 'children', type: 'ReactNode', description: '可选的可见内容覆盖；label 仍然是必需的（用于无障碍名称）。大多数情况使用 <Button label="Save" />。'},
     {
@@ -361,7 +361,7 @@ export const docsDense = {
     value: 'HTML value for form submission',
     form: 'associates button with form element by ID',
     isLoading: 'shows spinner+disables interaction; announces via live region',
-    icon: 'icon element rendered before label text',
+    icon: 'icon element rendered before label text; unsized Astryx Icon defaults to sm for sm/md buttons and md for lg',
     isIconOnly: 'when true, renders square icon-only button; label becomes aria-label',
     width: "Width of button. Numbers=pixels, strings=as-is (e.g. '100%' for full-width).",
     children: 'optional visible override; label is still required for a11y. Prefer <Button label="Save" /> over using children',

package/src/Button/Button.tsx

@@ -38,6 +38,8 @@ import {
 } from '../theme/tokens.stylex';
 import {Spinner} from '../Spinner';
 import {VisuallyHidden} from '../VisuallyHidden';
+import {IconDefaultSizeProvider} from '../Icon/IconDefaultSizeContext';
+import {iconBoxSizeStyles, type IconSize} from '../Icon/IconSize.stylex';
 
 import {EDGE_COMP_ATTR} from '../Layout/edgeCompensation.stylex';
 import {useSize} from '../SizeContext/SizeContext';
@@ -170,17 +172,6 @@ const sizeStyles = stylex.create({
   },
 });
 
-/**
- * Icon size per button size.
- * Matches Icon sizing: sm/md=16px, lg=20px.
- * fontSize is set so emoji and text-based icons scale correctly.
- */
-const iconSizeStyles = stylex.create({
-  sm: {width: 16, height: 16, fontSize: 16},
-  md: {width: 16, height: 16, fontSize: 16},
-  lg: {width: 20, height: 20, fontSize: 20},
-});
-
 /**
  * Resting elevation for floating buttons (e.g. a FAB). `none` is the default
  * flat button; `low`/`med`/`high` map to the shadow token scale. 'none' stays
@@ -233,6 +224,12 @@ export type ButtonVariant = keyof ButtonVariantMap;
  */
 export type ButtonSize = keyof typeof sizeStyles;
 
+const iconSizeByButtonSize = {
+  sm: 'sm',
+  md: 'sm',
+  lg: 'md',
+} satisfies Record<ButtonSize, IconSize>;
+
 export interface ButtonProps extends BaseProps<HTMLButtonElement> {
   /** Ref forwarded to the root element */
   ref?: React.Ref<HTMLButtonElement>;
@@ -683,6 +680,8 @@ export function Button({
     style,
   );
 
+  const iconSize = iconSizeByButtonSize[size];
+
   const buttonContent = (
     <>
       {isLoadingState && (
@@ -705,8 +704,11 @@ export function Button({
         )}
         aria-hidden={isLoadingState || undefined}>
         {icon && (
-          <span {...stylex.props(styles.iconWrapper, iconSizeStyles[size])}>
-            {icon}
+          <span
+            {...stylex.props(styles.iconWrapper, iconBoxSizeStyles[iconSize])}>
+            <IconDefaultSizeProvider value={iconSize}>
+              {icon}
+            </IconDefaultSizeProvider>
           </span>
         )}
         {isIconOnly ? null : (

package/src/Button/__tests__/Button.a11y.chromium.spec.ts

@@ -21,7 +21,13 @@
  *   ./Button.a11y.known-failures.ts, both shared with the jsdom lane.
  */
 
-import {expect, test, type CDPSession, type Page} from '@playwright/test';
+import {
+  expect,
+  test,
+  type CDPSession,
+  type Locator,
+  type Page,
+} from '@playwright/test';
 import {
   BUTTON_PATTERN,
   blockingResults,
@@ -93,6 +99,14 @@ async function activationsOn(page: Page): Promise<number> {
   return Number(raw ?? '0');
 }
 
+function pointerTargetFor(
+  page: Page,
+  state: ButtonBindingRow,
+): Locator | undefined {
+  const selector = (state as ButtonBindingState).pointerTargetSelector;
+  return selector == null ? undefined : page.locator(selector).first();
+}
+
 async function runState(
   page: Page,
   cdp: CDPSession,
@@ -111,6 +125,7 @@ async function runState(
       return createChromiumHarness({
         page,
         subject: page.locator('#storybook-root').getByRole('button').first(),
+        pointerTarget: pointerTargetFor(page, state),
         cdp,
       });
     },
@@ -306,6 +321,7 @@ test('every expectation is exercised by at least one bound state', async ({
               .locator('#storybook-root')
               .getByRole('button')
               .first(),
+            pointerTarget: pointerTargetFor(page, state),
             cdp,
           });
         },

package/src/Button/__tests__/Button.a11y.known-failures.ts

@@ -83,33 +83,4 @@ export const BUTTON_KNOWN_FAILURES: ReadonlyArray<KnownFailure> = [
     userImpact: 'The same, from an icon button.',
     reason: 'Inherited from Button, as above.',
   },
-
-  // ---- ClickableCard's role-bearing element cannot be clicked -------------
-  {
-    expectation: 'button.action.survives-an-aborted-press',
-    binding: 'ClickableCard',
-    state: 'clickable-card',
-    evidenceLayer: 'real-browser',
-    failureEquals:
-      'a pointer press cannot land on this control: something else is on top of it at its own centre, so there is no press here to abort',
-    standardsReference: 'WCAG 2.2 2.5.2 Pointer Cancellation (Level A)',
-    userImpact:
-      'The same defect seen from the other side: pointer cancellation cannot be demonstrated on a control no pointer press can land on. Recorded rather than reported green — a serene pass here would claim an outcome nobody observed.',
-    reason:
-      'Same cause as the record above. It is a second record rather than a wider one because a known failure names exactly one outcome, and these two would be fixed and verified separately.',
-  },
-  {
-    expectation: 'button.action.runs-on-pointer',
-    binding: 'ClickableCard',
-    state: 'clickable-card',
-    evidenceLayer: 'real-browser',
-    failureEquals:
-      'a pointer could not reach this control within 2000ms: the browser never found it visible, stable, and able to receive a pointer event. Something is covering it, or it is clipped to nothing.',
-    standardsReference:
-      'Current Astryx buttons family FR2 and WAI-ARIA APG Button operability requirement; supports WCAG 2.2 4.1.2 Name, Role, Value (Level A)',
-    userImpact:
-      "Anyone whose tooling acts on the accessible object rather than on pixels — a speech-input user saying the card's name, or assistive technology dispatching a click at the element it is told is the button — aims at a 1×1 control the card's own content paints over. A sighted mouse user is unaffected: they click the card surface, which handles it.",
-    reason:
-      'ClickableCard deliberately splits the surface that takes the click from the hidden button that carries the role and name. Reconciling the two is a design-system decision, not a change this contract should make.',
-  },
 ];

package/src/Button/__tests__/Button.a11y.renders.tsx

@@ -88,12 +88,19 @@ export const BUTTON_STATE_RENDERS: Record<ButtonStateId, StateRender> = {
   ),
 
   'clickable-card': activate => (
-    <ClickableCard label="Open billing settings" onClick={activate}>
+    <ClickableCard
+      data-a11y-pointer-target
+      label="Open billing settings"
+      onClick={activate}>
       <div>Billing</div>
     </ClickableCard>
   ),
   'clickable-card-disabled': activate => (
-    <ClickableCard label="Open billing settings" isDisabled onClick={activate}>
+    <ClickableCard
+      data-a11y-pointer-target
+      label="Open billing settings"
+      isDisabled
+      onClick={activate}>
       <div>Billing</div>
     </ClickableCard>
   ),