@astryxdesign/core 0.6.0 → 0.6.1

package/src/DropdownMenu/DropdownMenuSelectable.test.tsx

@@ -3,14 +3,14 @@
 /**
  * @file DropdownMenuSelectable.test.tsx
  * @input vitest, @testing-library/react, DropdownMenu + selectable items
- * @output Unit tests for DropdownMenuCheckboxItem / RadioGroup / RadioItem (#3829)
- * @position Component-local callback and composition coverage; shared checkbox
- *   role, name, state, and interaction outcomes live in the reusable contract.
+ * @output Component-local callback, composition, and marker styling tests for
+ *   DropdownMenuCheckboxItem / RadioGroup / RadioItem (#3829)
+ * @position Shared checkbox and radio-group role, name, state, and interaction
+ *   outcomes live in their reusable contracts; Menu retains navigation.
  */
 
 import {describe, it, expect, vi, beforeEach} from 'vitest';
 import {render, screen} from '@testing-library/react';
-import {useState} from 'react';
 import userEvent from '@testing-library/user-event';
 import {DropdownMenu} from './DropdownMenu';
 import {DropdownMenuCheckboxItem} from './DropdownMenuCheckboxItem';
@@ -120,61 +120,6 @@ describe('DropdownMenuCheckboxItem', () => {
 });
 
 describe('DropdownMenuRadioGroup / RadioItem', () => {
-  it('keeps option-2 unchecked until it is activated', async () => {
-    const user = userEvent.setup();
-
-    function RadioPreview() {
-      const [value, setValue] = useState('option-1');
-      return (
-        <DropdownMenu button={{label: 'Sort'}}>
-          <DropdownMenuRadioGroup
-            value={value}
-            onChange={setValue}
-            label="Radio group">
-            <DropdownMenuRadioItem value="option-2" label="Option 2" />
-          </DropdownMenuRadioGroup>
-        </DropdownMenu>
-      );
-    }
-
-    render(<RadioPreview />);
-    await user.click(screen.getByRole('button', {name: /Sort/}));
-
-    const option = screen.getByRole('menuitemradio', {
-      name: 'Option 2',
-      hidden: true,
-    });
-    expect(option).toHaveAttribute('aria-checked', 'false');
-
-    await user.click(option);
-    expect(option).toHaveAttribute('aria-checked', 'true');
-  });
-
-  it('renders a named group with radios reflecting the selected value', async () => {
-    const user = userEvent.setup();
-    render(
-      <DropdownMenu button={{label: 'Sort'}}>
-        <DropdownMenuRadioGroup
-          value="newest"
-          onChange={() => {}}
-          label="Sort by">
-          <DropdownMenuRadioItem value="newest" label="Newest" />
-          <DropdownMenuRadioItem value="oldest" label="Oldest" />
-        </DropdownMenuRadioGroup>
-      </DropdownMenu>,
-    );
-    await user.click(screen.getByRole('button', {name: /Sort/}));
-    expect(
-      screen.getByRole('menuitemradio', {name: 'Newest', hidden: true}),
-    ).toHaveAttribute('aria-checked', 'true');
-    expect(
-      screen.getByRole('menuitemradio', {name: 'Oldest', hidden: true}),
-    ).toHaveAttribute('aria-checked', 'false');
-    expect(
-      screen.getByRole('group', {name: 'Sort by', hidden: true}),
-    ).toBeInTheDocument();
-  });
-
   it('renders the shared radio indicator in the menu marker', async () => {
     const user = userEvent.setup();
     render(
@@ -236,24 +181,6 @@ describe('DropdownMenuRadioGroup / RadioItem', () => {
     expect(onChange).toHaveBeenCalledWith('oldest');
   });
 
-  it('names the group from the required label prop', async () => {
-    const user = userEvent.setup();
-    render(
-      <DropdownMenu button={{label: 'Sort'}}>
-        <DropdownMenuRadioGroup
-          value="newest"
-          onChange={() => {}}
-          label="Sort by">
-          <DropdownMenuRadioItem value="newest" label="Newest" />
-        </DropdownMenuRadioGroup>
-      </DropdownMenu>,
-    );
-    await user.click(screen.getByRole('button', {name: /Sort/}));
-    expect(
-      screen.getByRole('group', {name: 'Sort by', hidden: true}),
-    ).toBeInTheDocument();
-  });
-
   it('throws when a radio item is used outside a group', () => {
     const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
     expect(() =>

package/src/Field/Field.test.tsx

@@ -538,4 +538,46 @@ describe('Field', () => {
       expect(labelWrapper.querySelector('label')).not.toBeNull();
     });
   });
+
+  describe('local stacking ownership', () => {
+    // Input wrappers paint their surface above the attached status message
+    // box through a local z-index, so that layer must be contained by a
+    // Field-owned isolation boundary. Otherwise a detached or tooltip field
+    // — whose input wrapper renders outside the attached-status wrapper —
+    // competes with page-level stacking (AppShell sticky header, later
+    // siblings) and can paint over unrelated chrome (#5689).
+    it.each(['attached', 'detached', 'tooltip'] as const)(
+      'isolates the field surface for the %s status variant',
+      variant => {
+        render(
+          <Field
+            label="Name"
+            inputID="name-input"
+            status={{type: 'error', message: 'Required'}}
+            statusVariant={variant}
+            data-testid="field">
+            <input id="name-input" data-testid="control" />
+          </Field>,
+        );
+        const field = screen.getByTestId('field');
+        // The Field root is the isolation owner: it stays at its normal
+        // parent paint level (it carries no positioning or z-index of its
+        // own) while containing every local layer — the input wrapper's 1
+        // and the attached status -1.
+        expect(getComputedStyle(field).isolation).toBe('isolate');
+        // Unpositioned and unranked — the owner never competes itself.
+        expect(getComputedStyle(field).zIndex).toBe('');
+      },
+    );
+
+    it('keeps a custom control without status isolated too', () => {
+      render(
+        <Field label="Name" inputID="name-input" data-testid="field">
+          <input id="name-input" data-testid="control" />
+        </Field>,
+      );
+      const field = screen.getByTestId('field');
+      expect(getComputedStyle(field).isolation).toBe('isolate');
+    });
+  });
 });

package/src/Field/Field.tsx

@@ -35,6 +35,12 @@ const styles = stylex.create({
   container: {
     display: 'flex',
     flexDirection: 'column',
+    // The Field root owns the local stacking boundary (AST-027): the input
+    // wrapper's z-index (1, above the attached status box) and the attached
+    // status layer (-1) order parts inside this surface only. Without this,
+    // detached/tooltip fields — whose input wrapper renders outside the
+    // attached-status wrapper — compete with page-level stacking (#5689).
+    isolation: 'isolate',
   },
   containerGap: {
     gap: spacingVars['--spacing-1'],

package/src/Field/InputClearButton.test.tsx

@@ -19,7 +19,11 @@ import path from 'node:path';
 import {describe, it, expect, vi, afterEach} from 'vitest';
 import {render, screen, fireEvent} from '@testing-library/react';
 import * as stylex from '@stylexjs/stylex';
-import {InputClearButton, type InputClearButtonProps} from './InputClearButton';
+import {
+  InputClearButton,
+  InternalInputClearButton,
+  type InputClearButtonProps,
+} from './InputClearButton';
 import {Icon, registerIcons, resetIcons} from '../Icon';
 import {defineTheme} from '../theme/defineTheme';
 import {generateThemeCSS} from '../theme/generateThemeRules';
@@ -323,3 +327,33 @@ describe('InputClearButton glyph source', () => {
     expect(getGlyph()).toContainElement(screen.getByTestId('custom-close'));
   });
 });
+
+describe('InputClearButton pointer and focus interactions', () => {
+  it('prevents default on pointerdown and mousedown to keep focus on input', () => {
+    render(<InputClearButton label="Clear" onClick={() => {}} />);
+    const button = screen.getByRole('button', {name: 'Clear'});
+
+    const pointerDownEvent = fireEvent.pointerDown(button);
+    expect(pointerDownEvent).toBe(false);
+
+    const mouseDownEvent = fireEvent.mouseDown(button);
+    expect(mouseDownEvent).toBe(false);
+  });
+
+  it('composes custom onPointerDown while preventing default in InternalInputClearButton', () => {
+    const handlePointerDown = vi.fn();
+    render(
+      <InternalInputClearButton
+        label="Clear"
+        onClick={() => {}}
+        onPointerDown={handlePointerDown}
+        onClickCapture={() => {}}
+      />,
+    );
+    const button = screen.getByRole('button', {name: 'Clear'});
+    const pointerDownEvent = fireEvent.pointerDown(button);
+
+    expect(handlePointerDown).toHaveBeenCalledTimes(1);
+    expect(pointerDownEvent).toBe(false);
+  });
+});

package/src/Field/InputClearButton.tsx

@@ -73,8 +73,8 @@ export interface InputClearButtonProps {
    * Extra class(es) for the clear glyph itself, merged onto the shared
    * `astryx-input-clear-icon` target. Used by inputs that shipped a
    * component-specific clear-icon target before the family converged here
-   * (e.g. `astryx-date-input-clear-icon`) to keep emitting it for a
-   * deprecation window; new callers don't need it.
+   * (e.g. `astryx-date-input-clear-icon`) to keep emitting it for backwards
+   * compatibility; new callers don't need it.
    */
   iconClassName?: string;
 }
@@ -117,8 +117,12 @@ function renderInputClearButton({
           }
         />
       }
+      onPointerDown={e => {
+        e.preventDefault();
+        onPointerDown?.(e);
+      }}
+      onMouseDown={e => e.preventDefault()}
       onClick={onClick}
-      onPointerDown={onPointerDown}
       onClickCapture={onClickCapture}
       isIconOnly
       xstyle={[styles.button, xstyle]}

package/src/Field/PanelSearchInput.tsx

@@ -225,14 +225,27 @@ export function PanelSearchInput({
     [onBlur],
   );
 
-  const handleClear = useCallback(() => {
-    onValueChange('');
-    // Clearing puts the caret back where the user was typing, matching
-    // TextInput's built-in clear.
-    if (typeof ref === 'object' && ref?.current) {
-      ref.current.focus();
-    }
-  }, [onValueChange, ref]);
+  const handleClear = useCallback(
+    (e?: React.MouseEvent<HTMLButtonElement>) => {
+      onValueChange('');
+      // Clearing puts the caret back where the user was typing, matching
+      // TextInput's built-in clear. Defer focus restoration past the button's
+      // unmount task so touch browsers don't jump page scroll on tap, while
+      // preserving synchronous focus for keyboard users.
+      if (!e || e.detail === 0) {
+        if (typeof ref === 'object' && ref?.current) {
+          ref.current.focus();
+        }
+      } else {
+        requestAnimationFrame(() => {
+          if (typeof ref === 'object' && ref?.current) {
+            ref.current.focus({preventScroll: true});
+          }
+        });
+      }
+    },
+    [onValueChange, ref],
+  );
 
   return (
     <div

package/src/FieldStatus/FieldStatus.spec.md

@@ -13,6 +13,8 @@ review_triggers: [public-api, behavior, theming, accessibility]
 verified_by:
   [
     packages/core/src/FieldStatus/FieldStatus.test.tsx,
+    packages/core/src/FieldStatus/__tests__/StatusMessage.a11y.test.tsx,
+    packages/core/src/FieldStatus/__tests__/StatusMessage.a11y.chromium.spec.ts,
     scripts/check-knowledge.mjs,
   ]
 modules: []
@@ -20,7 +22,7 @@ families: []
 design_specs: []
 architecture: [architecture:component-theming-surface]
 contributing: []
-system_specs: []
+system_specs: [spec:AST-009, spec:AST-020, spec:AST-021]
 ---
 
 # FieldStatus component contract
@@ -116,23 +118,28 @@ intentional decision.
 
 ### Performance and resources
 
-- **PR1 — Announcement work.** A message change schedules only the persistent
-  live-region announcement; FieldStatus owns no global event listeners,
-  observers, or measurements.
+- **PR1 — Channel-update work.** A message change schedules only the persistent
+  live-region update; FieldStatus owns no global event listeners, observers, or
+  measurements.
 
 ## Accessibility contract
 
-- **AR1 — Announcement channel.** Errors MUST announce through the persistent
-  assertive region; warnings and successes MUST announce through the persistent
-  polite region, including on first mount and when message or type changes.
+- **AR1 — Programmatic announcement channel.** Errors MUST update the persistent
+  assertive region; warnings and successes MUST update the persistent polite
+  region, including on first mount and when message or type changes, without
+  moving focus.
+- **AR5 — Assistive-technology output.** Claims about whether, when, or how the
+  message is spoken or presented in braille MUST be verified through the real-AT
+  evidence process in `spec:AST-009`; DOM and accessibility-tree checks prove
+  only programmatic exposure and routing.
 - **AR2 — Visible description.** The rendered message box MUST remain available
   to assistive technology for `aria-describedby` association and MUST NOT become
   its own newly mounted live region.
 - **AR3 — Non-color cue.** Detached status MUST include a leading status glyph so
   status is not conveyed only by color or position.
 - **AR4 — Redundant glyph.** The detached glyph MUST remain hidden from assistive
-  technology because the visible message already conveys and announces the
-  status.
+  technology because the visible message already conveys the status in text;
+  announcement output remains owned by AR5.
 
 ## Design relationships
 
@@ -140,7 +147,7 @@ intentional decision.
 | ---------------- | ---------------------------------------------------------- | ----------------------------------------------- | -------------- | ------------------ |
 | Message box      | Carries the visible validation treatment.                  | Current behavior and approved component intent. | Supporting     | FR1, FR3           |
 | Detached icon    | Adds a non-color status cue only in detached presentation. | Current behavior and approved component intent. | Supporting     | FR2, FR4, AR3      |
-| Message text     | Communicates the validation result in words.               | Current behavior and approved component intent. | Prominent      | FR1, AR1, AR2      |
+| Message text     | Communicates the validation result in words.               | Current behavior and approved component intent. | Prominent      | FR1, AR1, AR2, AR5 |
 
 Current behavior renders the detached icon before message text. The intended
 public theming ownership is the exact map below; it does not add a target or
@@ -167,13 +174,16 @@ change either presentation.
 
 ## Verification map
 
-| Contract            | Verification                                              | Representative states                             | Mutation or failure expectation                                                         | Audit section                     |
-| ------------------- | --------------------------------------------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------- | --------------------------------- |
-| FR1, FR2, AR3, AR4  | `FieldStatus.test.tsx` rendering and detached-icon suites | Attached and detached; all status types           | Removing or reordering presentation parts fails DOM and accessibility assertions.       | `audit:FieldStatus/anatomy`       |
-| FR3, FR4            | `FieldStatus.test.tsx` theme target suites                | Attached/detached; error/warning/success          | Removing a target or status reflection fails class/data-attribute assertions.           | `audit:FieldStatus/theming`       |
-| FR5, FR6            | `FieldStatus.test.tsx` forwarding and update suites       | Initial render and rerender                       | Breaking the released root or update behavior fails compatibility assertions.           | `audit:FieldStatus/behavior`      |
-| AR1, AR2            | `FieldStatus.test.tsx` announcement suites                | Mount, message update, type update, empty message | Reintroducing a local live region or misrouting severity fails announcement assertions. | `audit:FieldStatus/accessibility` |
-| Theming anatomy map | `scripts/check-knowledge.mjs`                             | Consumer anatomy and current targets              | Missing, extra, duplicated, prefixed, or stale mappings fail repository validation.     | `audit:FieldStatus/theming`       |
+| Contract            | Verification                                                            | Representative states                                         | Mutation or failure expectation                                                                                                       | Audit section                     |
+| ------------------- | ----------------------------------------------------------------------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------- |
+| FR1, FR2, AR3, AR4  | `FieldStatus.test.tsx` rendering and detached-icon suites               | Attached and detached; all status types                       | Removing or reordering presentation parts fails DOM and accessibility assertions.                                                     | `audit:FieldStatus/anatomy`       |
+| FR3, FR4            | `FieldStatus.test.tsx` theme target suites                              | Attached/detached; error/warning/success                      | Removing a target or status reflection fails class/data-attribute assertions.                                                         | `audit:FieldStatus/theming`       |
+| FR5, FR6            | `FieldStatus.test.tsx` forwarding and update suites                     | Initial render and rerender                                   | Breaking the released root or update behavior fails compatibility assertions.                                                         | `audit:FieldStatus/behavior`      |
+| AR1                 | `StatusMessage.a11y.test.tsx` and `StatusMessage.a11y.chromium.spec.ts` | Error, warning, and success; post-mount message replacement   | Removing the persistent channel, changing its role/urgency, or dropping a post-mount update fails the shared status-message contract. | `audit:FieldStatus/accessibility` |
+| AR1                 | `FieldStatus.test.tsx` channel-routing suite                            | First non-empty mount; same-instance message and type changes | Breaking FieldStatus's first-use hook call or severity rerouting fails component-specific assertions.                                 | `audit:FieldStatus/accessibility` |
+| AR5                 | Pending/unverified real-AT evidence governed by `spec:AST-009`          | First mount; message replacement; type/urgency change         | Spoken and braille output remain unverified until a durable named AT/browser receipt exists.                                          | `audit:FieldStatus/accessibility` |
+| AR2                 | `FieldStatus.test.tsx`                                                  | Attached/detached visible message and empty message           | The visible description becomes a second live region or is hidden from assistive technology.                                          | `audit:FieldStatus/accessibility` |
+| Theming anatomy map | `scripts/check-knowledge.mjs`                                           | Consumer anatomy and current targets                          | Missing, extra, duplicated, prefixed, or stale mappings fail repository validation.                                                   | `audit:FieldStatus/theming`       |
 
 ## Decision log
 

package/src/FieldStatus/FieldStatus.test.tsx

@@ -53,7 +53,8 @@ describe('FieldStatus', () => {
       expect(el).not.toHaveAttribute('aria-live');
     });
 
-    // Errors are urgent — they interrupt via the assertive channel.
+    // These remain local because they exercise FieldStatus's first-use hook
+    // routing. The shared binding starts from an already established channel.
     it('announces error messages assertively, including on first mount', async () => {
       render(<FieldStatus type="error" message="This field is required" />);
       await waitFor(() => {
@@ -62,7 +63,7 @@ describe('FieldStatus', () => {
       expect(politeRegion()).toHaveTextContent('');
     });
 
-    it('announces warning messages politely', async () => {
+    it('announces warning messages politely on first mount', async () => {
       render(<FieldStatus type="warning" message="Check this value" />);
       await waitFor(() => {
         expect(politeRegion()).toHaveTextContent('Check this value');
@@ -70,14 +71,14 @@ describe('FieldStatus', () => {
       expect(assertiveRegion()).toHaveTextContent('');
     });
 
-    it('announces success messages politely', async () => {
+    it('announces success messages politely on first mount', async () => {
       render(<FieldStatus type="success" message="Looks good" />);
       await waitFor(() => {
         expect(politeRegion()).toHaveTextContent('Looks good');
       });
     });
 
-    it('announces message changes', async () => {
+    it('announces message changes through the component hook', async () => {
       const {rerender} = render(<FieldStatus type="error" message="First" />);
       await waitFor(() => {
         expect(assertiveRegion()).toHaveTextContent('First');
@@ -88,7 +89,8 @@ describe('FieldStatus', () => {
       });
     });
 
-    // Severity changes re-route the announcement to the matching channel.
+    // The generic contract checks each fixed urgency. This local test protects
+    // the component-specific same-instance type reroute.
     it('re-routes to the polite channel when type changes from error', async () => {
       const {rerender} = render(<FieldStatus type="error" message="msg" />);
       await waitFor(() => {

package/src/FieldStatus/__tests__/StatusMessage.a11y.chromium.spec.ts

@@ -0,0 +1,198 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file StatusMessage.a11y.chromium.spec.ts
+ * @input Uses the shared status-message contract, checked-in stories, Core state inventory, and exact known failures
+ * @output Real-browser and accessibility-tree evidence for every current Core status-message binding
+ * @position Browser migration lane; it makes no claim about assistive-technology speech or timing
+ */
+
+import {
+  expect,
+  test,
+  type CDPSession,
+  type Locator,
+  type Page,
+} from '@playwright/test';
+import {
+  STATUS_MESSAGE_PATTERN,
+  blockingResults,
+  checkAccessibilitySpec,
+  formatFailures,
+  formatReport,
+  neverExercised,
+  summarize,
+  unmatchedKnownFailures,
+  type BindingResult,
+} from '@astryxdesign/a11y-spec';
+import {
+  createChromiumHarness,
+  holdMotionStill,
+} from '@astryxdesign/a11y-spec/chromium';
+import {
+  DEFAULT_STORYBOOK_DIR,
+  serveStorybook,
+  type StaticServer,
+} from '@astryxdesign/a11y-spec/storybook';
+import {CORE_STATUS_MESSAGE_KNOWN_FAILURES} from './StatusMessage.a11y.known-failures';
+import {
+  CORE_STATUS_MESSAGE_BINDING_STATES,
+  type CoreStatusMessageBindingState,
+} from './StatusMessage.a11y.states';
+
+function transitionTestId(name: string): string {
+  return `status-transition-${name}`;
+}
+
+let storybook: StaticServer;
+
+test.beforeAll(async () => {
+  storybook = await serveStorybook(
+    process.env.ASTRYX_STORYBOOK_DIR ?? DEFAULT_STORYBOOK_DIR,
+  );
+});
+
+test.afterAll(async () => {
+  await storybook?.close();
+});
+
+function storyUrl(storyId: string): string {
+  return `${storybook.origin}/iframe.html?id=${storyId}&viewMode=story`;
+}
+
+const BOUND_SUBJECT_ATTRIBUTE = 'data-a11y-binding-subject';
+
+function subjectFor(page: Page): Locator {
+  return page.locator(`[${BOUND_SUBJECT_ATTRIBUTE}]`);
+}
+
+async function bindSubject(
+  page: Page,
+  state: CoreStatusMessageBindingState,
+): Promise<void> {
+  const facts = state.facts;
+  const role = facts.kind === 'progressbar' ? 'progressbar' : facts.role;
+  if (role == null) {
+    throw new Error(
+      `${state.id}: this component binding declares no public role`,
+    );
+  }
+  const candidates = page.getByRole(role, {includeHidden: true});
+  let target: Locator;
+  if (facts.kind === 'progressbar') {
+    target = page.getByRole(role, {includeHidden: true, name: facts.name});
+  } else if (facts.messageSource === 'accessible-name') {
+    target = page.getByRole(role, {
+      includeHidden: true,
+      name: facts.initialMessage,
+    });
+  } else {
+    const texts = await candidates.evaluateAll(elements =>
+      elements.map(element =>
+        (element.textContent ?? '').replace(/\s+/g, ' ').trim(),
+      ),
+    );
+    const indexes = texts.flatMap((text, index) =>
+      text === facts.initialMessage ? [index] : [],
+    );
+    if (indexes.length !== 1) {
+      throw new Error(
+        `${state.id}: expected one ${role} subject in initial state, found ${indexes.length}`,
+      );
+    }
+    target = candidates.nth(indexes[0]);
+  }
+  await expect(target).toHaveCount(1);
+  await target.evaluate((element, attribute) => {
+    element.setAttribute(attribute, '');
+  }, BOUND_SUBJECT_ATTRIBUTE);
+}
+
+async function mountState(
+  page: Page,
+  state: CoreStatusMessageBindingState,
+): Promise<void> {
+  await page.goto(storyUrl(state.storyId), {waitUntil: 'load'});
+  await holdMotionStill(page);
+  await page.locator('[data-a11y-ready="true"]').waitFor({state: 'attached'});
+  await bindSubject(page, state);
+  await subjectFor(page).waitFor({state: 'attached'});
+  await expect(subjectFor(page)).toHaveCount(1);
+  if ('focusSelector' in state) {
+    await expect(page.locator(state.focusSelector)).toHaveAttribute(
+      'aria-describedby',
+      /\S+/,
+    );
+  }
+}
+
+async function transition(page: Page, name: string): Promise<void> {
+  await page
+    .getByTestId(transitionTestId(name))
+    .evaluate(element => (element as HTMLElement).click());
+  await page.evaluate(
+    async () =>
+      new Promise<void>(resolve =>
+        requestAnimationFrame(() => requestAnimationFrame(() => resolve())),
+      ),
+  );
+}
+
+async function runState(
+  page: Page,
+  cdp: CDPSession,
+  state: CoreStatusMessageBindingState,
+): Promise<BindingResult> {
+  return checkAccessibilitySpec({
+    spec: STATUS_MESSAGE_PATTERN,
+    binding: state.binding,
+    state: state.id,
+    facts: state.facts,
+    knownFailures: CORE_STATUS_MESSAGE_KNOWN_FAILURES,
+    mount: async () => {
+      await mountState(page, state);
+      return createChromiumHarness({
+        page,
+        cdp,
+        subject: subjectFor(page),
+        related: {
+          'focus-anchor': page.locator(
+            'focusSelector' in state
+              ? state.focusSelector
+              : '[data-a11y-relation="focus-anchor"]',
+          ),
+        },
+      });
+    },
+    transition: async name => transition(page, name),
+  });
+}
+
+test('every expectation is exercised by at least one Core binding state', async ({
+  page,
+}) => {
+  test.setTimeout(4 * 60 * 1000);
+  const cdp = await page.context().newCDPSession(page);
+  const results: BindingResult[] = [];
+  for (const state of CORE_STATUS_MESSAGE_BINDING_STATES) {
+    results.push(await runState(page, cdp, state));
+  }
+  expect(neverExercised(results)).toEqual([]);
+  expect(
+    unmatchedKnownFailures(CORE_STATUS_MESSAGE_KNOWN_FAILURES, results),
+  ).toEqual([]);
+});
+
+for (const state of CORE_STATUS_MESSAGE_BINDING_STATES) {
+  test(`${state.binding} [${state.id}] — ${state.summary}`, async ({page}) => {
+    test.setTimeout(2 * 60 * 1000);
+    const cdp = await page.context().newCDPSession(page);
+    const result = await runState(page, cdp, state);
+    const report = summarize(STATUS_MESSAGE_PATTERN, [result]);
+    // eslint-disable-next-line no-console -- the report is this run's artifact
+    console.log(formatReport(report));
+    expect(formatFailures(blockingResults([result]))).toBe('');
+    expect(report.unrunLayers).toEqual([]);
+    expect(report.counts.unexpectedPass).toBe(0);
+  });
+}

package/src/FieldStatus/__tests__/StatusMessage.a11y.known-failures.ts

@@ -0,0 +1,13 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file StatusMessage.a11y.known-failures.ts
+ * @input Uses the exact known-failure vocabulary from the shared runner
+ * @output Public-safe Core status-message debt records (currently none)
+ * @position Migration debt only; operational ownership is maintained outside this public repository
+ */
+
+import type {KnownFailure} from '@astryxdesign/a11y-spec';
+
+export const CORE_STATUS_MESSAGE_KNOWN_FAILURES: ReadonlyArray<KnownFailure> =
+  [];