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

package/src/Switch/Switch.doc.mjs

@@ -210,6 +210,17 @@ export const docs = {
     ],
   },
   usage: {
+    accessibility: [
+      {
+        name: 'Track and thumb',
+        category: 'Color contrast',
+        criterion: '1.4.11 Non-text Contrast',
+        requirement: '3:1',
+        states: ['Rest', 'Hover', 'Pointer down'],
+        description:
+          'The on and off tracks must each have at least 3:1 contrast with the surface behind them, and the thumb with its track. For Hover and Pointer down, measure the final colors after the tint and the pressed overlay are applied.',
+      },
+    ],
     anatomy,
     description:
       'A toggle control for on/off states that take effect immediately. Supports labels, descriptions, loading states, and validation. Use it for settings or preferences that apply instantly. For changes requiring a form submission, use a checkbox instead.',

package/src/Switch/Switch.test.tsx

@@ -30,6 +30,7 @@ import {
   getAllInjectedCss,
   getForcedColorsRules,
 } from '../__tests__/forcedColors';
+import {hasPressedArm} from '../__tests__/pressState';
 import {__resetLiveRegionsForTest} from '../hooks/useAnnounce';
 
 afterEach(() => {
@@ -755,6 +756,21 @@ describe('Switch', () => {
     });
   });
 
+  describe('pressed state', () => {
+    it('paints the pressed overlay on the track and the thumb while the row is pressed', () => {
+      const {container} = render(
+        <Switch label="Notifications" value={false} onChange={() => {}} />,
+      );
+      const track = container.querySelector('.astryx-switch');
+      const thumb = container.querySelector('.astryx-switch-thumb');
+      if (track == null || thumb == null) {
+        throw new Error('the switch has no track or thumb to press');
+      }
+      expect(hasPressedArm(track)).toBe(true);
+      expect(hasPressedArm(thumb)).toBe(true);
+    });
+  });
+
   describe('coarse pointer and RTL hit-target positioning', () => {
     it.each([
       ['sm', 'ltr'],

package/src/Switch/Switch.tsx

@@ -122,6 +122,15 @@ const thumbOnSizeStyles = stylex.create({
   },
 });
 
+// The pressed overlay, painted as a gradient layer OVER the track's and
+// thumb's own fills so it composes with the on/off colors and the hover tint
+// instead of replacing them. Same token Button's overlay paints with. The
+// switch is a two-part control whose focusable input sits beside the track,
+// so the press is read off the shared scope marker (the row), the way the
+// hover tint already is: pressing the input, the track or the label all
+// activate the row.
+const pressedImage = `linear-gradient(${colorVars['--color-overlay-pressed']}, ${colorVars['--color-overlay-pressed']})`;
+
 const labelWrapperSizeStyles = stylex.create({
   sm: {
     minHeight: 20,
@@ -207,6 +216,15 @@ const styles = stylex.create({
       default: null,
       '@media (forced-colors: active)': 'CanvasText',
     },
+    // Pressed: the overlay rides on top of the on/off fill. Gated like the
+    // hover tint so forced colors keeps its system-color track.
+    backgroundImage: {
+      default: null,
+      [stylex.when.ancestor(':active', switchScope)]: {
+        default: null,
+        '@media (forced-colors: none)': pressedImage,
+      },
+    },
   },
   // The one ring in the system not drawn by focusOutlineStyles. The focusable
   // input is a sibling of the track, so the condition has to reach the shared
@@ -278,6 +296,16 @@ const styles = stylex.create({
       '@media (prefers-reduced-motion: reduce)': '0s',
     },
     transitionTimingFunction: easeVars['--ease-standard'],
+    // Pressed: the same overlay as the track, so the whole control darkens
+    // under the finger rather than the thumb standing out against a darker
+    // track.
+    backgroundImage: {
+      default: null,
+      [stylex.when.ancestor(':active', switchScope)]: {
+        default: null,
+        '@media (forced-colors: none)': pressedImage,
+      },
+    },
   },
   // The thumb fill lives on the on/off styles (not the shared thumb style)
   // because forced colors needs a per-state system color: CanvasText on the

package/src/TabList/Tab.tsx

@@ -137,6 +137,15 @@ const styles = stylex.create({
       [stylex.when.ancestor(':hover', tabScope)]: {
         '@media (hover: hover)': colorVars['--color-overlay-hover'],
       },
+      // Pressed: the same layer steps up to the pressed overlay, read off the
+      // tab the way the hover is, so a press paints on a finger too. Repeated
+      // inside the hover-capable branch so it outranks the hover rule there
+      // (a media-nested rule carries extra generated priority; see
+      // interactionOverlay.stylex.ts).
+      [stylex.when.ancestor(':active', tabScope)]: {
+        default: colorVars['--color-overlay-pressed'],
+        '@media (hover: hover)': colorVars['--color-overlay-pressed'],
+      },
     },
     transitionProperty: 'background-color',
     transitionDuration: durationVars['--duration-fast'],
@@ -249,6 +258,7 @@ export function Tab({
   xstyle,
   className,
   style,
+  onClick,
   ...restProps
 }: TabProps) {
   const tabListCtx = useTabListContext();
@@ -263,9 +273,23 @@ export function Tab({
   const displayIcon = isSelected && selectedIcon ? selectedIcon : icon;
   const hasVisibleLabel = !isLabelHidden && label !== '';
 
-  const handleSelect = useCallback(() => {
-    tabListCtx.onChange(value);
-  }, [tabListCtx, value]);
+  const isDisabled =
+    restProps['aria-disabled'] === true ||
+    restProps['aria-disabled'] === 'true';
+
+  const handleSelect = useCallback(
+    (event: React.MouseEvent<HTMLButtonElement | HTMLAnchorElement>) => {
+      if (isDisabled) {
+        event.preventDefault();
+        return;
+      }
+      onClick?.(event as React.MouseEvent<HTMLButtonElement>);
+      if (!event.defaultPrevented) {
+        tabListCtx.onChange(value);
+      }
+    },
+    [isDisabled, onClick, tabListCtx, value],
+  );
 
   useDevWarning(
     'Tab',
@@ -339,7 +363,7 @@ export function Tab({
         sizeStyles[size],
         isSelected && styles.selected,
         isFill && layoutStyles.fill,
-        tabScope,
+        !isDisabled && tabScope,
         xstyle,
       ),
       className,
@@ -382,10 +406,14 @@ export function Tab({
   ) : null;
 
   if (isLink) {
+    // A disabled link tab must not reach a router component: some routers reject
+    // a missing destination, while others treat it as the current route. A
+    // plain anchor without href preserves the element shape but cannot navigate.
+    const LinkRoot = isDisabled ? 'a' : LinkComponent;
     return (
-      <LinkComponent
+      <LinkRoot
         ref={ref}
-        href={href}
+        href={isDisabled ? undefined : href}
         onClick={handleSelect}
         {...sharedProps}>
         {hoverBgElement}
@@ -393,7 +421,7 @@ export function Tab({
         {labelElement}
         {endContentElement}
         {indicatorElement}
-      </LinkComponent>
+      </LinkRoot>
     );
   }
 

package/src/TabList/TabList.doc.mjs

@@ -103,6 +103,17 @@ export const docs = {
     {name: 'TabMenu'},
   ],
   usage: {
+    accessibility: [
+      {
+        name: 'Tab label',
+        category: 'Color contrast',
+        criterion: '1.4.3 Contrast (Minimum)',
+        requirement: '4.5:1',
+        states: ['Rest', 'Hover', 'Pointer down', 'Selected'],
+        description:
+          'Each label must have at least 4.5:1 contrast with the tab surface behind it. For Hover and Pointer down, measure the final background after the overlay layer is applied.',
+      },
+    ],
     description:
       'TabList provides tab-style navigation for organizing content into categorized sections. Use it to let users switch between related views without leaving the page, with overflow items handled by a built-in "more" menu.',
     bestPractices: [

package/src/TabList/TabList.spec.md

@@ -0,0 +1,204 @@
+---
+schema_version: 3
+template_version: 5
+kind: component
+id: component:TabList
+authority: current
+archive_reason: null
+superseded_by: null
+approved_by: cixzhang
+approved_at: 2026-09-21
+owners: [cixzhang]
+review_triggers: [public-api, behavior, layout, accessibility]
+verified_by:
+  [
+    packages/core/src/TabList/TabList.test.tsx,
+    apps/storybook/stories/TabList.stories.tsx,
+    scripts/check-knowledge.mjs,
+  ]
+modules: []
+families: []
+design_specs: []
+architecture:
+  [architecture:container-padding, architecture:public-component-api]
+contributing: [contributing:api-conventions]
+system_specs: [spec:AST-002/DEC-1, spec:AST-002/DEC-2, spec:AST-017/DEC-1]
+---
+
+# TabList component contract
+
+## Contract at a glance
+
+| Area                    | Contract                                                                                                                                                                                                                                                                           |
+| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Public contract         | Canonicalize the existing alignment mode as `edgeCompensation?: 'inline'`; deprecate `isFullBleed` and remove it in the next minor release.                                                                                                                                        |
+| Behavior                | Move first and last visible tab content toward the host content line, reaching it when the host inset is at least the edge-tab padding, while preserving tab interaction padding, focus-ring room, overflow controls, selection-indicator geometry, and the optional divider rail. |
+| End-user impact         | Edge tabs lose unnecessary extra inset where host geometry permits and remain fully interactive without clipped focus, selection, overflow, or divider treatment.                                                                                                                  |
+| Builder impact          | Existing `isFullBleed` callsites keep working during the deprecation window and migrate mechanically to `edgeCompensation="inline"`.                                                                                                                                               |
+| Compatibility/readiness | Current behavior is shipped; the canonical alias is additive, while removing the released legacy prop is a separately implemented breaking change in the next minor release.                                                                                                       |
+| Review checks           | Reject a behavior change disguised as a rename, directional values without overflow/indicator proof, or early removal of the legacy prop.                                                                                                                                          |
+| Governing rules         | `architecture:container-padding/INV9–INV11`; `spec:AST-002/DEC-1–DEC-2`; `spec:AST-017/DEC-1`.                                                                                                                                                                                     |
+
+This table is a review projection; the body below is authoritative.
+
+## Intent
+
+TabList's current opt-in is edge compensation: it consumes the full inherited
+host inset, moves visible edge-tab content toward the surrounding content line,
+and retains Tab-owned interaction padding plus TabList-owned divider, overflow,
+and indicator geometry. Content reaches the host line only when that inset is at
+least the edge tab's own padding. The public `isFullBleed` name is misleading
+because the strip restores uncovered content inset after the outer box expands.
+
+## Compatibility and migration
+
+- Released default preserved: `yes`; omission keeps current TabList geometry.
+- Compatibility class: the canonical alias is additive while the released
+  `isFullBleed` prop remains; removing that prop is a breaking change in the next
+  minor release under `spec:AST-017/DEC-1`.
+- Controlled/uncontrolled behavior: active-value control is unchanged.
+- Migration decision: `component:TabList/DEC-1`.
+
+During the compatibility window:
+
+- `edgeCompensation="inline"` is the canonical spelling;
+- omitted `edgeCompensation` plus `isFullBleed={true}` selects the same mode;
+- `isFullBleed` is deprecated and maintained examples use the canonical prop;
+- if both props are supplied, explicit `edgeCompensation` is canonical and the
+  legacy boolean cannot disable it.
+
+The removal release MUST include a `[breaking]` Changeset for
+`@astryxdesign/core`, consumer release notes, and an `astryx upgrade` codemod that rewrites
+`isFullBleed` to `edgeCompensation="inline"`.
+
+## Ownership boundary
+
+**Owns**
+
+- The TabList-wide edge-compensation mode and its compatibility alias.
+- The relationship between the outer TabList box, inner strip padding, edge tabs,
+  focus-ring room, overflow controls, and selection indicator.
+- Which logical edges are supported by the public mode.
+
+**Does not own / non-goals**
+
+- Host padding publication, nesting, or overlay resets — owned by
+  `architecture:container-padding`.
+- Button or List edge-compensation projections.
+- New `start` or `end` values without separate proof and owner approval.
+- A change to navigation/tab semantics, selection state, keyboard behavior, or
+  overflow ownership.
+
+## Public concepts
+
+| Concept           | Closed values or states  | Meaning                                                                                                                                              | Availability by variant/orientation/state                          | Default         | Owner               | Stability                       | Invalid-value behavior                                 |
+| ----------------- | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ | --------------- | ------------------- | ------------------------------- | ------------------------------------------------------ |
+| Edge compensation | omitted, `inline`        | Consume both inherited inline host insets and move edge-tab content toward the host lines while retaining local interaction and strip-owned geometry | Navigation and tabs patterns across current layout/overflow states | omitted         | `component:TabList` | accepted; canonical API pending | Other values are rejected by the public type           |
+| Legacy alias      | omitted, `false`, `true` | Compatibility spelling for omitted or inline edge compensation                                                                                       | Until the next minor release                                       | omitted/`false` | `component:TabList` | deprecated                      | `true` maps to `inline`; explicit canonical input wins |
+
+## Behavioral and layout contract
+
+| ID  | Invariant                                                                                                                                                                                                                                                                                                                                                                                                                                      | Basis                                                             | Status                                                   |
+| --- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- | -------------------------------------------------------- |
+| FR1 | The current opt-in MUST remain edge compensation: the outer TabList box consumes the full inherited inline host inset and any `hasDivider` rail spans that expanded width; the inner strip restores `max(host inset - edge-tab padding, 0)` at each logical edge. Visible edge-tab content reaches the host line only when the host inset is at least the tab padding; otherwise it moves toward that line without crossing the host boundary. | Current source and `component:TabList/DEC-1`                      | Shipped behavior                                         |
+| FR2 | Compensation MUST preserve Tab interaction padding, focus-ring room, overflow detection and controls, scroll access, selection-indicator geometry, and the optional divider rail's expanded inline span.                                                                                                                                                                                                                                       | Current source plus owner direction                               | Shipped behavior; expanded evidence required with rename |
+| FR3 | `edgeCompensation?: 'inline'` MUST become the canonical API without changing FR1–FR2 geometry or the omitted default.                                                                                                                                                                                                                                                                                                                          | `architecture:container-padding/INV10`; `component:TabList/DEC-1` | Accepted contract; implementation pending                |
+| FR4 | During the deprecation window, omitted `edgeCompensation` plus `isFullBleed={true}` MUST produce the canonical `inline` behavior. Explicit `edgeCompensation` MUST remain authoritative when both props are supplied.                                                                                                                                                                                                                          | Compatibility decision                                            | Accepted contract; implementation pending                |
+| FR5 | `isFullBleed` MUST be removed in the next minor release only after maintained docs/examples use `edgeCompensation`, both paths have compatibility evidence, and the removal includes a `[breaking]` Changeset plus an `astryx upgrade` codemod for mechanical consumer migration.                                                                                                                                                              | `component:TabList/DEC-1`; `spec:AST-017/DEC-1`                   | Accepted contract; implementation pending                |
+| FR6 | `start` and `end` MUST remain rejected until per-edge overflow, clipping, scroll-control, focus-ring, indicator, direction, and theme-padding evidence receives owner approval.                                                                                                                                                                                                                                                                | Shared logical vocabulary and TabList boundary                    | Accepted boundary                                        |
+
+### Allowed variation
+
+- Layout, size, role, selected value, labels, tab content, and overflow mode may
+  vary while the same edge-compensation meaning is preserved.
+- The implementation may retain the current outer-box/inner-strip technique or
+  replace it with equivalent geometry that satisfies FR1–FR2.
+- A host may be painted or bounded only where TabList's component-specific
+  evidence proves the outer box, clipping, focus, and indicator behavior safe.
+
+### Representative states
+
+| State                 | Required invariant                                                                                                       | Allowed variation                                                                               |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------- |
+| Default/omitted       | Current TabList box, strip, and tab geometry are unchanged.                                                              | Any current layout, role, or overflow mode.                                                     |
+| Canonical inline mode | Outer box consumes each host inset; edge content reaches the host line only when that inset is at least the tab padding. | Host inset smaller than, equal to, or larger than edge-tab padding; asymmetric insets; LTR/RTL. |
+| Divider               | `hasDivider` rail spans the expanded outer inline width.                                                                 | Fitting or overflowing strips.                                                                  |
+| Legacy alias          | `isFullBleed={true}` matches canonical inline geometry during the compatibility window.                                  | The canonical prop may also be present.                                                         |
+| Overflowing strip     | Scroll access, edge fades, controls, and selected-tab reveal remain correct.                                             | Start/end overflow independently.                                                               |
+| Focused edge tab      | The focus ring remains visible and local to the tab.                                                                     | Keyboard or pointer focus.                                                                      |
+
+### Transformation and precedence order
+
+- **ORD1 — Public input.** Resolve explicit `edgeCompensation`; otherwise map
+  `isFullBleed={true}` to `inline` during the compatibility window; otherwise use
+  no compensation.
+- **ORD2 — Host geometry.** Read the matching inherited logical host insets, with
+  missing values falling back to zero.
+- **ORD3 — Component geometry.** Resolve edge-tab padding and focus/indicator
+  allowances from TabList-owned sources, restore the non-overlapping portion of
+  each content inset, and preserve interaction padding and owned affordances.
+
+### Performance and resources
+
+- **PR1 — CSS-first geometry.** The rename MUST add no observer, listener,
+  state, Effect, or render pass. Existing overflow measurement remains unchanged.
+
+## Accessibility contract
+
+- **AR1 — Interaction remains stable.** Edge compensation MUST NOT change the
+  tab/nav pattern, accessible names, selected state, keyboard movement, tab stop,
+  focus target, or controlled value behavior.
+- **AR2 — Overflow remains reachable.** Compensated edge geometry MUST NOT clip or
+  hide a focus ring, selected indicator, visible tab content, or an overflow
+  control required to reach offscreen tabs.
+
+## Design relationships
+
+| Anatomy or state  | Design requirement                                                                                    | Representation authority  | Hierarchy role | Component contract |
+| ----------------- | ----------------------------------------------------------------------------------------------------- | ------------------------- | -------------- | ------------------ |
+| Outer TabList box | Consumes the full inherited inline host inset; with `hasDivider`, its rail spans that expanded width. | `component:TabList/DEC-1` | Supporting     | FR1–FR3            |
+| Inner strip       | Restores `max(host inset - edge-tab padding, 0)` and owns scrolling/fades.                            | Current TabList behavior  | Structural     | FR1–FR2            |
+| Edge Tab          | Retains interaction padding and visible focus/selection treatment.                                    | Tab composition           | Prominent      | FR1–FR2, AR1–AR2   |
+
+## Family and system relationships
+
+- `architecture:container-padding` owns host publication, the shared
+  `edgeCompensation` vocabulary, logical-edge semantics, and overlay reset.
+- `architecture:public-component-api` and `spec:AST-002` own public API
+  admission; `spec:AST-017/DEC-1` owns the breaking classification and migration
+  evidence required when the released alias is removed.
+- TabList owns its specialized host, overflow, focus, and indicator projection.
+
+## Verification map
+
+| Contract         | Verification                                                                                                            | Representative states                                                                                                                           | Mutation or failure expectation                                                                            | Audit section          |
+| ---------------- | ----------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | ---------------------- |
+| FR1–FR4          | `TabList.test.tsx` and type/docs tests                                                                                  | omitted, canonical, legacy, both props, and `hasDivider`                                                                                        | Alias drift, changed defaults, wrong precedence, or lost divider span fails                                | `audit:TabList/api`    |
+| FR1–FR6, AR1–AR2 | Real-browser TabList geometry and interaction evidence                                                                  | LTR/RTL; host inset smaller/equal/larger than edge-tab padding; asymmetric/zero inset; divider; fitting/overflowing; selected/focused edge tabs | Wrong bounded movement, clipped focus/indicator/divider, inaccessible overflow, or scroll regression fails | `audit:TabList/visual` |
+| FR5 and docs     | `TabList.doc.mjs`, Storybook, `[breaking]` Changeset, `astryx upgrade` codemod tests, and `scripts/check-knowledge.mjs` | canonical examples, deprecated alias, and removal migration                                                                                     | Missing migration guidance, wrong Changeset class, missing codemod rewrite, or stale canonical usage fails | `audit:TabList/docs`   |
+
+## Decision log
+
+### DEC-1 — TabList migrates from full-bleed wording to edge compensation
+
+**Reference:** `component:TabList/DEC-1`
+
+**Decider:** cixzhang, 2026-09-21
+
+TabList's current mode consumes the full inherited inline host inset, keeps an
+optional divider across that expanded width, and restores only the portion of
+content inset not already supplied by edge-tab padding. The user-facing intent is
+therefore edge compensation, not a promise that tab content itself reaches an
+outer edge. `edgeCompensation="inline"` becomes the canonical spelling;
+`isFullBleed` remains a compatibility alias until its `[breaking]` next-minor
+removal, with the required codemod and release evidence.
+
+## Open questions
+
+None.
+
+## Content boundary
+
+This claim-scoped contract does not duplicate TabList's complete navigation,
+selection, overflow, or theming contract, consumer examples, implementation
+steps, or List/Button projections. Those remain with their named owners.

package/src/TabList/TabList.test.tsx

@@ -12,6 +12,7 @@
 import {describe, it, expect, vi, beforeAll, afterAll} from 'vitest';
 import {render, screen, fireEvent} from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
+import {hasPressedArm} from '../__tests__/pressState';
 import {TabList} from './TabList';
 import type {TabListProps} from './TabList';
 import {Tab} from './Tab';
@@ -1515,3 +1516,68 @@ describe('TabList ARIA pattern — any other role', () => {
     );
   });
 });
+
+describe('pressed state', () => {
+  it('paints the pressed overlay on the tab surface while the tab is pressed', () => {
+    render(
+      <TabList value="home" onChange={() => {}}>
+        <Tab value="home" label="Home" />
+        <Tab value="settings" label="Settings" />
+      </TabList>,
+    );
+    const tab = screen.getByRole('button', {name: 'Settings'});
+    // The hover surface is a child layer read off the tab; the press paints
+    // the same layer, so the assertion is on that layer.
+    const surface = tab.querySelector('span[aria-hidden="true"]');
+    if (surface == null) {
+      throw new Error('the tab has no hover surface to press');
+    }
+    expect(hasPressedArm(surface)).toBe(true);
+  });
+
+  it('does not activate a disabled button tab or call its handler', async () => {
+    const user = userEvent.setup();
+    const onChange = vi.fn();
+    const onClick = vi.fn();
+    render(
+      <TabList value="home" onChange={onChange}>
+        <Tab value="home" label="Home" />
+        <Tab
+          value="settings"
+          label="Settings"
+          aria-disabled="true"
+          onClick={onClick}
+        />
+      </TabList>,
+    );
+    const tab = screen.getByRole('button', {name: 'Settings'});
+    await user.click(tab);
+    expect(onClick).not.toHaveBeenCalled();
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('removes navigation from a disabled link tab', () => {
+    const onChange = vi.fn();
+    const {container} = render(
+      <LinkProvider component={CustomLink}>
+        <TabList value="home" onChange={onChange}>
+          <Tab value="home" label="Home" />
+          <Tab
+            value="settings"
+            label="Settings"
+            href="/settings"
+            aria-disabled="true"
+          />
+        </TabList>
+      </LinkProvider>,
+    );
+    const tab = container.querySelector('a');
+    if (tab == null) {
+      throw new Error('the disabled link tab did not render an anchor');
+    }
+    expect(tab).not.toHaveAttribute('data-custom-link');
+    expect(tab).not.toHaveAttribute('href');
+    fireEvent.click(tab);
+    expect(onChange).not.toHaveBeenCalled();
+  });
+});

package/src/TabList/__tests__/Tabs.a11y.known-failures.ts

@@ -9,37 +9,4 @@
 
 import type {KnownFailure} from '@astryxdesign/a11y-spec';
 
-const COMMON = {
-  binding: 'Tab',
-  state: 'tab-disabled-unselected',
-  evidenceLayer: 'real-browser',
-  standardsReference:
-    'WCAG 2.2 4.1.2 Name, Role, Value; WAI-ARIA 1.2 aria-disabled',
-  reason:
-    'This migration records the existing behavior without changing the component interaction contract.',
-} as const;
-
-export const TABS_KNOWN_FAILURES: ReadonlyArray<KnownFailure> = [
-  {
-    ...COMMON,
-    expectation: 'tabs.tab.unavailable-pointer-inert',
-    failureEquals:
-      'the tab is reported unavailable, but clicking it selected it',
-    userImpact:
-      'A pointer user can activate a tab that assistive technology reports as unavailable.',
-  },
-  {
-    ...COMMON,
-    expectation: 'tabs.tab.unavailable-enter-inert',
-    failureEquals: 'the tab is reported unavailable, but Enter selected it',
-    userImpact:
-      'A keyboard user can activate a focusable tab with Enter after assistive technology reports it unavailable.',
-  },
-  {
-    ...COMMON,
-    expectation: 'tabs.tab.unavailable-space-inert',
-    failureEquals: 'the tab is reported unavailable, but Space selected it',
-    userImpact:
-      'A keyboard user can activate a focusable tab with Space after assistive technology reports it unavailable.',
-  },
-];
+export const TABS_KNOWN_FAILURES: ReadonlyArray<KnownFailure> = [];

package/src/Table/Table.doc.mjs

@@ -12,7 +12,7 @@ const anatomy = [
     name: 'Scroll region',
     required: true,
     description:
-      'Keyboard-focusable outer region that scrolls horizontally when the columns overflow.',
+      'Outer region that scrolls horizontally, enters the keyboard order, and contains overscroll only while the columns overflow.',
   },
   {
     name: 'Header section',