@astryxdesign/core 0.7.1 → 0.7.2-canary.020e1fe

package/src/TabList/TabList.spec.md

@@ -31,10 +31,10 @@ system_specs: [spec:AST-002/DEC-1, spec:AST-002/DEC-2, spec:AST-017/DEC-1]
 
 | Area                    | Contract                                                                                                                                                                                                                                                                           |
 | ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Public contract         | Canonicalize the existing alignment mode as `edgeCompensation?: 'inline'`; deprecate `isFullBleed` and remove it in the next minor release.                                                                                                                                        |
+| Public contract         | Canonicalize the existing mode as `edge?: 'padded' \| 'bleed'` (default `'padded'`) from the shared `edge` vocabulary; deprecate `isFullBleed` as an alias of `edge="bleed"` 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"`.                                                                                                                                               |
+| Builder impact          | Existing `isFullBleed` callsites keep working during the deprecation window and migrate mechanically to `edge="bleed"`.                                                                                                                                                            |
 | 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`.                                                                                                                                                                                     |
@@ -43,12 +43,13 @@ 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,
+TabList's current opt-in is the shared `bleed` edge treatment: 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.
+because the strip keeps a content line: it restores uncovered content inset
+after the outer box expands, which `architecture:container-padding` names `bleed`.
 
 ## Compatibility and migration
 
@@ -61,21 +62,21 @@ because the strip restores uncovered content inset after the outer box expands.
 
 During the compatibility window:
 
-- `edgeCompensation="inline"` is the canonical spelling;
-- omitted `edgeCompensation` plus `isFullBleed={true}` selects the same mode;
+- `edge="bleed"` is the canonical spelling, and omitted `edge` means `padded`;
+- omitted `edge` plus `isFullBleed={true}` selects `bleed`;
 - `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.
+- if both props are supplied, explicit `edge` is canonical and the legacy
+  boolean cannot override 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"`.
+`isFullBleed` to `edge="bleed"`.
 
 ## Ownership boundary
 
 **Owns**
 
-- The TabList-wide edge-compensation mode and its compatibility alias.
+- The TabList-wide `bleed` edge treatment 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.
@@ -84,33 +85,34 @@ The removal release MUST include a `[breaking]` Changeset for
 
 - 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.
+- Button or List edge projections.
+- The `flush` or `outset` values, or per-edge application, 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 |
+| Concept        | Closed values or states    | Meaning                                                                                                                                                                                           | Availability by variant/orientation/state                          | Default            | Owner               | Stability                       | Invalid-value behavior                       |
+| -------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ | ------------------ | ------------------- | ------------------------------- | -------------------------------------------- |
+| Edge treatment | omitted, `padded`, `bleed` | `bleed`: consume both inherited inline host insets and move edge-tab content toward the host lines while retaining local interaction and strip-owned geometry; `padded`: current default geometry | Navigation and tabs patterns across current layout/overflow states | omitted (`padded`) | `component:TabList` | accepted; canonical API pending | Other values are rejected by the public type |
+| Legacy alias   | omitted, `false`, `true`   | Compatibility spelling for `padded` or `bleed`                                                                                                                                                    | Until the next minor release                                       | omitted/`false`    | `component:TabList` | deprecated                      | `true` maps to `bleed`; explicit `edge` 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                                        |
+| ID  | Invariant                                                                                                                                                                                                                                                                                                                                                                                                                                          | Basis                                                             | Status                                                   |
+| --- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- | -------------------------------------------------------- |
+| FR1 | The current opt-in MUST remain the `bleed` treatment: 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 | `edge?: 'padded' \| 'bleed'` MUST become the canonical API, with `bleed` selecting FR1–FR2 geometry and `padded` the omitted default, without changing either.                                                                                                                                                                                                                                                                                     | `architecture:container-padding/INV10`; `component:TabList/DEC-1` | Accepted contract; implementation pending                |
+| FR4 | During the deprecation window, omitted `edge` plus `isFullBleed={true}` MUST produce the canonical `bleed` behavior. Explicit `edge` 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 `edge`, 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 | `flush`, `outset`, and per-edge application MUST remain rejected until overflow, clipping, scroll-control, focus-ring, indicator, direction, and theme-padding evidence receives owner approval.                                                                                                                                                                                                                                                   | Shared edge 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.
+  vary while the same `bleed` 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
@@ -118,20 +120,20 @@ The removal release MUST include a `[breaking]` Changeset for
 
 ### 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.                                                                      |
+| State             | Required invariant                                                                                                       | Allowed variation                                                                               |
+| ----------------- | ------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------- |
+| Default/omitted   | Current TabList box, strip, and tab geometry are unchanged.                                                              | Any current layout, role, or overflow mode.                                                     |
+| Canonical `bleed` | 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 `bleed` 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.
+- **ORD1 — Public input.** Resolve explicit `edge`; otherwise map
+  `isFullBleed={true}` to `bleed` during the compatibility window; otherwise use
+  `padded`.
 - **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
@@ -145,10 +147,10 @@ The removal release MUST include a `[breaking]` Changeset for
 
 ## Accessibility contract
 
-- **AR1 — Interaction remains stable.** Edge compensation MUST NOT change the
+- **AR1 — Interaction remains stable.** The `bleed` treatment 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
+- **AR2 — Overflow remains reachable.** `bleed` geometry MUST NOT clip or
   hide a focus ring, selected indicator, visible tab content, or an overflow
   control required to reach offscreen tabs.
 
@@ -162,8 +164,8 @@ The removal release MUST include a `[breaking]` Changeset for
 
 ## Family and system relationships
 
-- `architecture:container-padding` owns host publication, the shared
-  `edgeCompensation` vocabulary, logical-edge semantics, and overlay reset.
+- `architecture:container-padding` owns host publication, the shared `edge`
+  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.
@@ -189,9 +191,20 @@ 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.
+outer edge. DEC-2 sets the canonical spelling; `isFullBleed` remains a
+compatibility alias until its `[breaking]` next-minor removal, with the required
+codemod and release evidence.
+
+### DEC-2 — TabList spells its mode with the shared edge vocabulary
+
+**Reference:** `component:TabList/DEC-2`
+
+**Decider:** cixzhang, 2026-10-16
+
+`architecture:container-padding` names TabList's geometry `bleed`: paint reaches
+the host's padding edge and content stays on the host content line, or at the
+edge tab's own padding when the host inset is smaller. `edge="bleed"` is the
+canonical spelling, so TabList and List share one prop name and one value set.
 
 ## Open questions
 

package/src/TabList/TabList.test.tsx

@@ -783,6 +783,73 @@ describe('TabMenu', () => {
   });
 });
 
+describe('TabMenu host attributes', () => {
+  const menuOptions = [
+    {value: 'analytics', label: 'Analytics'},
+    {value: 'reports', label: 'Reports'},
+  ];
+
+  it('forwards host attributes to the trigger, not the popup', () => {
+    render(
+      <TabList value="home" onChange={() => {}}>
+        <Tab value="home" label="Home" />
+        <TabMenu
+          label="More"
+          options={menuOptions}
+          id="more-tabs"
+          aria-label="More views"
+          data-view="overflow"
+        />
+      </TabList>,
+    );
+
+    const trigger = screen.getByRole('button', {name: 'More views'});
+    expect(trigger).toHaveAttribute('id', 'more-tabs');
+    expect(trigger).toHaveAttribute('data-view', 'overflow');
+    const menu = screen.getByRole('menu', {name: 'More', hidden: true});
+    expect(trigger).toHaveAttribute('aria-controls', menu.id);
+  });
+
+  it('runs drag-and-drop handlers on the trigger', () => {
+    const onDragOver = vi.fn();
+    const onDrop = vi.fn();
+    render(
+      <TabList value="home" onChange={() => {}}>
+        <Tab value="home" label="Home" />
+        <TabMenu
+          label="More"
+          options={menuOptions}
+          onDragOver={onDragOver}
+          onDrop={onDrop}
+        />
+      </TabList>,
+    );
+    const trigger = screen.getByRole('button', {name: 'More'});
+    fireEvent.dragOver(trigger);
+    fireEvent.drop(trigger);
+    expect(onDragOver).toHaveBeenCalledTimes(1);
+    expect(onDrop).toHaveBeenCalledTimes(1);
+    expect(trigger).toHaveAttribute('aria-expanded', 'false');
+  });
+
+  it('onClick preserves the toggle', async () => {
+    const user = userEvent.setup();
+    const onClick = vi.fn((event: React.MouseEvent<HTMLButtonElement>) => {
+      event.preventDefault();
+    });
+    render(
+      <TabList value="home" onChange={() => {}}>
+        <Tab value="home" label="Home" />
+        <TabMenu label="More" options={menuOptions} onClick={onClick} />
+      </TabList>,
+    );
+    const trigger = screen.getByRole('button', {name: 'More'});
+    await user.click(trigger);
+    expect(onClick).toHaveBeenCalledTimes(1);
+    expect(trigger).toHaveAttribute('aria-expanded', 'true');
+  });
+});
+
 describe('TabMenu keyboard navigation (roving tabindex)', () => {
   const menuOptions = [
     {value: 'analytics', label: 'Analytics'},

package/src/TabList/TabMenu.doc.mjs

@@ -7,7 +7,7 @@ export const docs = {
   subComponentOf: 'TabList',
   displayName: 'Tab Menu',
   isHiddenFromOverview: true,
-  description: "Overflow menu trigger that opens a dropdown of additional tab options, showing the selected option's label as the trigger text.",
+  description: "Overflow menu trigger that opens a dropdown of additional tab options, showing the selected option's label as the trigger text. Host attributes and DOM event handlers (id, aria-*, data-*, drag and drop) reach the trigger button, not the popup or its options. The button keeps its role, tab stop, and menu disclosure attributes.",
   // TabMenu requires TabList context; wrap it so the preview doesn't throw.
   // The wrapper value matches none of the options, so the trigger shows its
   // own label (the idle overflow state).
@@ -42,7 +42,7 @@ export const docsZh = {
   name: 'TabMenu',
   isHiddenFromOverview: true,
   displayName: 'Tab Menu',
-  description: '溢出菜单触发器，打开包含额外标签选项的下拉菜单，将选中选项的标签显示为触发器文本。',
+  description: '溢出菜单触发器，打开包含额外标签选项的下拉菜单，将选中选项的标签显示为触发器文本。宿主属性和 DOM 事件处理器（id、aria-*、data-*、拖放）传递给触发按钮，而不是弹出菜单或选项。按钮保留自己的角色、Tab 停靠点及菜单展开属性。',
   props: [
     {
       name: 'label',
@@ -63,7 +63,8 @@ export const docsDense = {
   name: 'TabMenu',
   isHiddenFromOverview: true,
   displayName: 'Tab Menu',
-  description: "Overflow menu trigger; dropdown of extra tab options, shows selected option's label as trigger text.",
+  description:
+    "Overflow menu trigger; shows selected option's label. Host attributes/DOM handlers reach the trigger button, not the popup/options; role, tab stop and disclosure attributes stay owned.",
   propDescriptions: {
     label: 'Trigger text (when no option selected) + dropdown heading.',
     options: 'Menu options array rendered in dropdown.',

package/src/TabList/TabMenu.tsx

@@ -37,7 +37,7 @@ import {useListFocus} from '../hooks/useListFocus';
 import {useTabListContext} from './TabListContext';
 import type {TabListSize} from './TabListContext';
 import {tabScope} from './tab.markers.stylex';
-import {mergeProps} from '../utils';
+import {composeEventHandlers, mergeProps} from '../utils';
 import {useMergedRefs} from '../hooks/useMergedRefs';
 import type {BaseProps} from '../BaseProps';
 import {themeProps} from '../utils/themeProps';
@@ -51,9 +51,9 @@ export interface TabMenuOption {
   icon?: ReactNode | IconType;
 }
 
-export interface TabMenuProps extends Pick<
+export interface TabMenuProps extends Omit<
   BaseProps<HTMLButtonElement>,
-  'xstyle' | 'className' | 'style'
+  'role' | 'tabIndex' | 'aria-haspopup' | 'aria-expanded' | 'aria-controls'
 > {
   ref?: React.Ref<HTMLButtonElement>;
   /**
@@ -263,6 +263,8 @@ export function TabMenu({
   xstyle,
   className,
   style,
+  onClick,
+  ...rest
 }: TabMenuProps) {
   const tabListCtx = useTabListContext();
   const menuId = useId();
@@ -346,6 +348,7 @@ export function TabMenu({
   return (
     <>
       <button
+        {...rest}
         ref={setButtonRef}
         type="button"
         aria-haspopup="menu"
@@ -353,7 +356,7 @@ export function TabMenu({
         aria-controls={menuId}
         data-tab-menu=""
         tabIndex={hasSelectedOption ? 0 : -1}
-        onClick={handleToggle}
+        onClick={composeEventHandlers(handleToggle, onClick)}
         {...mergeProps(
           themeProps('tab-menu'),
           focusOutlineProps.focusVisible(

package/src/Text/Text.test.tsx

@@ -346,3 +346,60 @@ describe('truncated text shows one tooltip, not two', () => {
     }
   });
 });
+
+// With hasTruncateTooltip={false} nothing reads the measured overflow, so a
+// long table of truncated cells must not pay a layout read per cell.
+function countScrollWidthReads(run: () => void): number {
+  const proto = window.HTMLElement.prototype;
+  const original = Object.getOwnPropertyDescriptor(proto, 'scrollWidth');
+  let reads = 0;
+  Object.defineProperty(proto, 'scrollWidth', {
+    configurable: true,
+    get() {
+      reads += 1;
+      return 0;
+    },
+  });
+  try {
+    run();
+  } finally {
+    if (original) {
+      Object.defineProperty(proto, 'scrollWidth', original);
+    } else {
+      delete (proto as {scrollWidth?: number}).scrollWidth;
+    }
+  }
+  return reads;
+}
+
+describe('Text maxLines without a truncation tooltip', () => {
+  it('takes no truncation measurement when hasTruncateTooltip is false', () => {
+    const reads = countScrollWidthReads(() => {
+      render(
+        <>
+          {Array.from({length: 20}, (_, index) => (
+            <Text
+              type="body"
+              maxLines={1}
+              hasTruncateTooltip={false}
+              key={index}>
+              Cell {index} with text far wider than its column
+            </Text>
+          ))}
+        </>,
+      );
+    });
+    expect(reads).toBe(0);
+  });
+
+  it('still measures when the tooltip is enabled', () => {
+    const reads = countScrollWidthReads(() => {
+      render(
+        <Text type="body" maxLines={1}>
+          Text far wider than its column
+        </Text>,
+      );
+    });
+    expect(reads).toBeGreaterThan(0);
+  });
+});

package/src/Text/Text.tsx

@@ -260,8 +260,12 @@ export function Text({
   // Resolve display - force block when maxLines > 0 or hasCapsize
   const resolvedDisplay = maxLines > 0 || hasCapsize ? 'block' : display;
 
-  // Truncation detection
-  const truncation = useTruncation({maxLines});
+  // Truncation detection. Only the tooltip reads the measured overflow, so
+  // with the tooltip off the text is clipped by CSS alone and nothing is
+  // measured or observed.
+  const truncation = useTruncation({
+    maxLines: hasTruncateTooltip === false ? 0 : maxLines,
+  });
 
   // Tooltip for truncated text
   const tooltipPlacement: LayerPlacement =

package/src/Text/useTruncation.test.tsx

@@ -0,0 +1,69 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file useTruncation.test.tsx
+ * Tests for useTruncation
+ */
+
+import {render, screen, waitFor} from '@testing-library/react';
+import {afterEach, describe, it, expect, vi} from 'vitest';
+import {useTruncation} from './useTruncation';
+
+function Probe({text}: {text: string}) {
+  const truncation = useTruncation({maxLines: 1});
+  return (
+    <>
+      <span ref={truncation.ref}>{text}</span>
+      <output data-testid="full-text">{truncation.fullText}</output>
+    </>
+  );
+}
+
+// A status line at a fixed width never resizes when its message changes, so
+// the tooltip text must follow the content, not only the element's size.
+describe('useTruncation', () => {
+  it('re-measures when the text changes without a resize', async () => {
+    const {rerender} = render(<Probe text="planning the first step" />);
+    expect(screen.getByTestId('full-text')).toHaveTextContent(
+      'planning the first step',
+    );
+
+    rerender(<Probe text="writing the second step" />);
+
+    await waitFor(() =>
+      expect(screen.getByTestId('full-text')).toHaveTextContent(
+        'writing the second step',
+      ),
+    );
+  });
+
+  describe('content observation', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals();
+    });
+
+    it('shares one observer across every truncating instance', () => {
+      const NativeMutationObserver = globalThis.MutationObserver;
+      let created = 0;
+      vi.stubGlobal(
+        'MutationObserver',
+        class extends NativeMutationObserver {
+          constructor(callback: MutationCallback) {
+            super(callback);
+            created += 1;
+          }
+        },
+      );
+
+      render(
+        <>
+          {Array.from({length: 50}, (_, index) => (
+            <Probe key={index} text={`cell ${index}`} />
+          ))}
+        </>,
+      );
+
+      expect(created).toBe(1);
+    });
+  });
+});

package/src/Text/useTruncation.ts

@@ -4,7 +4,7 @@
 
 /**
  * @file useTruncation.ts
- * @input Uses React hooks, sharedResizeObserver
+ * @input Uses React hooks, sharedResizeObserver, sharedMutationObserver
  * @output Exports useTruncation hook for detecting text overflow
  * @position Hook; consumed by Text.tsx, Heading.tsx
  *
@@ -14,6 +14,7 @@
 
 import {useCallback, useRef, useState, type RefCallback} from 'react';
 import {observeResize} from '../utils/sharedResizeObserver';
+import {observeContent} from '../utils/sharedMutationObserver';
 
 export interface UseTruncationOptions {
   /**
@@ -43,10 +44,12 @@ export interface UseTruncationReturn {
 /**
  * Hook for detecting text overflow/truncation.
  *
- * Uses a shared ResizeObserver singleton (via observeResize)
- * for efficient detection when content or container changes. A single
- * ResizeObserver instance is shared across all mounted useTruncation hooks,
- * so even hundreds of table cells only create one observer.
+ * Uses a shared ResizeObserver singleton (via observeResize) for size
+ * changes and a shared MutationObserver singleton (via observeContent) for
+ * content changes, so even hundreds of table cells create one observer of
+ * each kind. Observing content matters because an element whose text changes
+ * without resizing (a fixed-width status line) must still be re-measured for
+ * the tooltip text and the truncated state to follow the current content.
  *
  * - Single-line: compares scrollWidth > offsetWidth
  * - Multi-line: uses Range.getBoundingClientRect() to measure actual content
@@ -71,6 +74,7 @@ export function useTruncation(
   const [fullText, setFullText] = useState('');
   const elementRef = useRef<HTMLElement | null>(null);
   const unobserveRef = useRef<(() => void) | null>(null);
+  const unobserveContentRef = useRef<(() => void) | null>(null);
 
   const checkTruncation = useCallback(
     (element: HTMLElement) => {
@@ -113,6 +117,8 @@ export function useTruncation(
       // by element leaves any other observer of the same node untouched.
       unobserveRef.current?.();
       unobserveRef.current = null;
+      unobserveContentRef.current?.();
+      unobserveContentRef.current = null;
 
       elementRef.current = element;
 
@@ -127,6 +133,11 @@ export function useTruncation(
         } else {
           checkTruncation(element);
         }
+        // New text in a box that keeps its size fires no resize, so the
+        // captured text and truncated state would otherwise stay stale.
+        unobserveContentRef.current = observeContent(element, () => {
+          checkTruncation(element);
+        });
       } else {
         setIsTruncated(false);
         setFullText('');

package/src/TimeInput/TimeInput.fr10.test.tsx

@@ -191,6 +191,21 @@ for (const [surface, presentation, selector] of SURFACES) {
       expect(own?.textContent).toContain('Start');
     });
 
+    it('puts hidden, inert, and dir on the control', () => {
+      render(
+        <TimeInput
+          label="Start"
+          presentation={presentation}
+          hidden
+          inert
+          dir="rtl"
+        />,
+      );
+      expect(control(selector)).toHaveAttribute('hidden');
+      expect(control(selector)).toHaveAttribute('inert');
+      expect(control(selector)).toHaveAttribute('dir', 'rtl');
+    });
+
     it('keeps control* on the control box in a horizontal-labels FormLayout', () => {
       vi.spyOn(console, 'warn').mockImplementation(() => {});
       const {container} = render(

package/src/Timestamp/Timestamp.doc.mjs

@@ -6,7 +6,7 @@ export const docs = {
   name: 'Timestamp',
   displayName: 'Timestamp',
   category: 'Content',
-  keywords: ['date', 'time', 'datetime', 'relative', 'ago', 'clock', 'format', 'duration'],
+  keywords: ['date', 'time', 'datetime', 'relative', 'ago', 'clock', 'format', 'duration', 'relativetime'],
   playground: {
     // `value` is required but has no semantic default, so the properties-tab
     // preview fell back to the literal string "value" — which