pixelize-native-library 1.2.0 → 1.2.1

package/lib/typescript/modules/button/Button.d.ts

@@ -1,9 +1,3 @@
-/**
- * Button — the reference component. The single most-repeated shape in the audited apps (81 raw
- * TouchableOpacity in crm-mobile, 155 in ecommerce-mobile with three different style-key sets for the
- * SAME add-to-cart button, 195 web usages). Every other module copies the patterns here: how variants
- * resolve, how `tone` maps to role colours, how accessibility is wired, and the shape of the tests.
- */
 import type { GestureResponderEvent, MouseEvent, NativeSyntheticEvent, TargetedEvent } from "react-native";
 import type { IconName } from "../../core/icon";
 import type { LayoutStyle } from "../../core/style";
@@ -15,21 +9,9 @@ interface ButtonBaseProps {
     iconPosition?: IconPosition;
     loading?: boolean;
     disabled?: boolean;
-    /**
-     * Toggle state for a button that stays on, e.g. a Bold/Italic toolbar control. ACCESSIBILITY ONLY
-     * — appearance stays with `variant`, which callers already swap for the active look; without this
-     * the on/off state is conveyed by colour alone (WCAG 1.4.1) and never announced (4.1.2).
-     * Omit it entirely on an ordinary button so it does not announce "not pressed".
-     */
     selected?: boolean;
     fullWidth?: boolean;
     onPress?: () => void;
-    /**
-     * The gesture/pointer/keyboard handlers below plus `accessibilityHint` are the exact set a
-     * wrapping `Tooltip` injects via `cloneElement`. Declared explicitly because `{...rest}` is banned
-     * repo-wide: an undeclared prop is dropped, so without these a tooltip on a Button never opens.
-     * Each is chained after Button's own press/focus state, never in place of it.
-     */
     onLongPress?: (event: GestureResponderEvent) => void;
     onPressOut?: (event: GestureResponderEvent) => void;
     onHoverIn?: (event: MouseEvent) => void;
@@ -37,21 +19,14 @@ interface ButtonBaseProps {
     onFocus?: (event: NativeSyntheticEvent<TargetedEvent>) => void;
     onBlur?: (event: NativeSyntheticEvent<TargetedEvent>) => void;
     accessibilityHint?: string;
-    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
     style?: LayoutStyle;
     testID?: string;
 }
-/** A button with a visible text label. `accessibilityLabel` defaults to `label`. */
 interface LabelledButtonProps extends ButtonBaseProps {
     label: string;
     icon?: IconName;
     accessibilityLabel?: string;
 }
-/**
- * An icon-only button. It has no visible text, so `accessibilityLabel` is REQUIRED at the type level
- * — the single worst a11y trap on web (its tooltip was the only label on icon-only buttons in 22
- * files, and tooltips do not exist on touch). `label?: never` makes the two shapes mutually exclusive.
- */
 interface IconOnlyButtonProps extends ButtonBaseProps {
     icon: IconName;
     label?: never;

package/lib/typescript/modules/button/Button.variants.d.ts

@@ -42,19 +42,19 @@ export interface ButtonSizeSpec {
  */
 export declare const BUTTON_SIZES: {
     readonly sm: {
-        readonly height: 32;
+        readonly height: 44;
         readonly fontSize: 14;
         readonly iconSize: 16;
         readonly hitSlop: number;
     };
     readonly md: {
-        readonly height: 40;
+        readonly height: 52;
         readonly fontSize: 16;
         readonly iconSize: 18;
         readonly hitSlop: number;
     };
     readonly lg: {
-        readonly height: 48;
+        readonly height: 56;
         readonly fontSize: 18;
         readonly iconSize: 20;
         readonly hitSlop: number;
@@ -137,15 +137,15 @@ export declare function resolveButtonAccessibility(input: ButtonAccessibilityInp
 export declare const buttonStructure: import("../../core/style").ThemedVariantResolver<Theme, {
     size: {
         sm: {
-            height: 32;
+            height: 44;
             paddingHorizontal: 12;
         };
         md: {
-            height: 40;
+            height: 52;
             paddingHorizontal: 16;
         };
         lg: {
-            height: 48;
+            height: 56;
             paddingHorizontal: 24;
         };
     };

package/lib/typescript/modules/button-group/ButtonGroup.d.ts

@@ -1,22 +1,3 @@
-/**
- * ButtonGroup — a segmented single-choice control. Visually connected segments sharing one outer
- * border and a divider line between adjacent segments, NOT a row of standalone `Button`s — that
- * connected/segmented treatment is a different structural shape than Button's own pill/rect
- * variants, so this is a standalone sibling (it never imports `../button`). The border/divider is
- * drawn PER SEGMENT, not once on the container: every edge that touches the selected segment omits
- * the stroke (see `resolveButtonGroupSegmentEdgeColors` — WCAG 1.4.11) and relies on the selected
- * fill's own contrast against the canvas instead.
- *
- * One component owns the whole group, same as `RadioGroup`: each segment carries its own
- * `accessibilityRole="radio"` + `accessibilityState.checked`, and the container carries
- * `accessibilityRole="radiogroup"` so assistive tech announces the grouping without collapsing the
- * individually-focusable segments into one.
- *
- * No animation anywhere, deliberately: selection is a conditional fill, and the segments share one
- * continuous border, so a per-segment press scale (Button's affordance) would visibly detach a
- * segment from the control it is part of. The `pressed` fill swap is the affordance instead. Nothing
- * animates, so — like `RadioGroup` — there is nothing here for reduce motion (WCAG 2.3.3) to gate.
- */
 import type { LayoutStyle } from "../../core/style";
 import type { ButtonGroupSize } from "./ButtonGroup.variants";
 export interface ButtonGroupOption {

package/lib/typescript/modules/button-group/ButtonGroup.variants.d.ts

@@ -50,8 +50,10 @@ export interface ButtonGroupColors {
     readonly selectedFill: string;
     /** Label on `selectedFill` — the derived on-colour, so it always clears 4.5:1 (never a hard white). */
     readonly onSelectedFill: string;
-    /** Unselected-segment label, read on the transparent (canvas) segment. */
+    /** Unselected-segment label, read on the group's `containerFill`. */
     readonly label: string;
+    /** The whole group's tonal fill, replacing the old outer hairline frame. */
+    readonly containerFill: string;
     /**
      * Unselected-segment background while pressed. `label` stays ≥ 4.5:1 on it (WCAG 1.4.3), and — the
      * fix this field exists for — it stays ≥ 3:1 against `selectedFill` (WCAG 1.4.11): when a segment
@@ -61,22 +63,8 @@ export interface ButtonGroupColors {
      * is `bg.sunken` nudged toward `bg.canvas` by a fixed-alpha overlay (see `resolveButtonGroupColors`).
      */
     readonly pressedFill: string;
-    /**
-     * The shared outline colour, used as the container's outer border and as the 1px divider between
-     * adjacent segments — this is what makes the control read as connected, not a row of
-     * separately-bordered buttons. It only ever gets DRAWN on an edge that touches two unselected
-     * segments (or one unselected segment and the group's own outside). WCAG 1.4.11: `outline`
-     * (`border.interactive`, a neutral grey) clears 3:1 against `bg.canvas` on every brand × mode, but
-     * measured directly against a SELECTED segment's `accent.solid` fill it fails 3:1 on 15 of 16
-     * brand × mode combinations (several catastrophically — slate light 1.00, emerald light 1.02).
-     * Since `value` is required, some segment is always selected, so that adjacency is not an edge
-     * case, it is every render. Rather than chase one stroke colour that can never clear 3:1 against
-     * both a near-white canvas AND every brand's accent fill at once, `resolveButtonGroupSegmentEdgeColors`
-     * omits the stroke on any edge that touches the selected segment and lets the fill-vs-canvas
-     * contrast serve as the boundary instead — the same mechanism every other solid-fill component in
-     * this library already relies on (`accent.solid` clears 3:1 against `bg.canvas` on all 16 brand ×
-     * mode combinations, worst case 3.24:1 on emerald light; see `ButtonGroup.test.ts`).
-     */
+    /** The 1px divider between two adjacent unselected segments — omitted where it touches the
+     * selected segment (WCAG 1.4.11), letting `selectedFill` vs `containerFill` carry the boundary. */
     readonly outline: string;
 }
 /**
@@ -95,21 +83,9 @@ export interface ButtonGroupSegmentEdgeInput {
     readonly nextSelected: boolean;
 }
 export interface ButtonGroupSegmentEdgeColors {
-    readonly top: string;
-    readonly bottom: string;
-    /** Only structurally drawn on the first segment (see `buttonGroupSegmentStructure`'s `first`
-     * variant) — harmless to compute for every segment. */
-    readonly left: string;
-    /** The internal divider for every segment except the last, where it is instead that segment's
-     * own outer right edge. */
+    /** The divider shared with the next segment — omitted where either side is selected. */
     readonly right: string;
 }
-/**
- * Per-edge, per-segment outline colour — the WCAG 1.4.11 fix. An edge draws the shared `outline`
- * colour only when BOTH sides of it are unselected; any edge touching the selected segment is
- * `transparent` instead, so the selected fill's own contrast against the canvas (or, for the
- * divider case, against the neighbour's transparent/canvas background) is what marks the boundary.
- */
 export declare function resolveButtonGroupSegmentEdgeColors(colors: ButtonGroupColors, input: ButtonGroupSegmentEdgeInput): ButtonGroupSegmentEdgeColors;
 export interface ButtonGroupSegmentPosition {
     readonly isFirst: boolean;
@@ -173,30 +149,20 @@ export interface ButtonGroupKeyInput {
  */
 export declare function resolveButtonGroupKeyIndex(input: ButtonGroupKeyInput): number | undefined;
 /**
- * The container — a clipping rect only. `overflow: hidden` + `borderRadius` clips every segment's
- * fill (and the outer segments' square corners) to this single rounded outline, so the selected
- * segment never shows a corner poking past the shared shape — the visual mechanism that makes this
- * read as ONE connected control rather than a row of standalone buttons. It carries NO border of its
- * own: the outer border is drawn by the first/last segments themselves (see
- * `buttonGroupSegmentStructure`), because only a per-segment border can be selectively omitted where
- * it touches the selected segment (WCAG 1.4.11) — a single container-wide border is one colour for
- * its entire perimeter and cannot vary by which segment it runs along.
+ * The container. `overflow: hidden` + `borderRadius` clips every segment's fill (and the outer
+ * segments' square corners) to one rounded shape, so the selected segment never pokes a corner past
+ * it. `backgroundColor: bg.raised` is the group's tonal frame — it replaces the old outer hairline,
+ * so unselected segments (transparent) read as sitting on one continuous raised surface.
  */
 export declare const buttonGroupStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
 /**
  * One segment's layout. `minWidth: MIN_TOUCH_TARGET` is the real ≥44dp touch-target floor for the
- * WIDTH axis — horizontal hitSlop can no longer safely pad an internal segment (see
- * `resolveButtonGroupSegmentHitSlop`), so the rendered node itself must never shrink narrower than
- * 44dp, for a realistic 2–4 option row at either size. `height` is fixed (not a minimum) so the
+ * WIDTH axis (see `resolveButtonGroupSegmentHitSlop`). `height` is fixed (not a minimum) so the
  * vertical hitSlop math holds against what actually renders.
  *
- * Every segment structurally carries a top, bottom, and right border (thin width) — the right one is
- * the divider on every segment except the last, where it is instead that segment's own outer right
- * edge. Only the FIRST segment gets a left border and left-corner radii (the group's own outer left
- * edge); only the LAST segment gets right-corner radii (matching the container's own `borderRadius`,
- * so that segment's own border curves rather than being clipped into an L by the container). Border
- * WIDTHS are structural and constant; COLOURS (drawn vs `transparent`) are resolved per render by
- * `resolveButtonGroupSegmentEdgeColors` and applied inline over this.
+ * Only a right border remains, structural on every segment but the last — the internal divider
+ * between two adjacent unselected segments (see `resolveButtonGroupSegmentEdgeColors`). There is no
+ * more top/bottom/left border: the container's own tonal fill carries the group's outer shape now.
  */
 export declare const buttonGroupSegmentStructure: import("../../core/style").ThemedVariantResolver<Theme, {
     size: {
@@ -211,18 +177,18 @@ export declare const buttonGroupSegmentStructure: import("../../core/style").The
     };
     first: {
         on: {
-            borderLeftWidth: 1;
-            borderTopLeftRadius: 8;
-            borderBottomLeftRadius: 8;
-        };
-        off: {
-            borderLeftWidth: number;
+            borderTopLeftRadius: 12;
+            borderBottomLeftRadius: 12;
+            borderCurve: "continuous";
         };
+        off: {};
     };
     last: {
         on: {
-            borderTopRightRadius: 8;
-            borderBottomRightRadius: 8;
+            borderTopRightRadius: 12;
+            borderBottomRightRadius: 12;
+            borderCurve: "continuous";
+            borderRightWidth: number;
         };
         off: {};
     };

package/lib/typescript/modules/card/Card.d.ts

@@ -1,20 +1,22 @@
 /**
- * Card — a plain container for grouping content. No interaction, no text of its own: `children` is
- * ordinary composition (a consumer places `Text`, `Button`, whatever it needs inside), so there is
- * nothing here for `accessibilityRole` to announce — the container is intentionally invisible to
- * assistive tech and its children carry their own semantics, exactly like a plain `View` would.
+ * Card — a plain container for grouping content, optionally pressable. When `onPress` is absent the
+ * root is a plain `View` with no press hook or animated values. Children carry their own semantics.
  */
 import type { ReactNode } from "react";
+import type { GestureResponderEvent } from "react-native";
 import type { LayoutStyle } from "../../core/style";
 import type { CardVariant } from "./Card.variants";
 export interface CardProps {
     variant?: CardVariant;
     children?: ReactNode;
+    onPress?: () => void;
+    onLongPress?: (event: GestureResponderEvent) => void;
+    disabled?: boolean;
     /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
     style?: LayoutStyle;
     testID?: string;
 }
-declare function CardImpl({ variant, children, style, testID }: CardProps): import("react").JSX.Element;
+declare function CardImpl({ variant, children, onPress, onLongPress, disabled, style, testID, }: CardProps): import("react").JSX.Element;
 export declare const Card: import("react").MemoExoticComponent<typeof CardImpl>;
 export {};
 //# sourceMappingURL=Card.d.ts.map

package/lib/typescript/modules/charts/Charts.variants.d.ts

@@ -3,8 +3,12 @@
  * (mocking only `react-native`'s `StyleSheet`, as every sibling module's tests do).
  */
 import type { RoleColors, StatusRole, Theme } from "../../theme/hooks";
+import type { DeviceTier } from "../../core/device";
 export type SparklineTone = "accent" | "neutral" | StatusRole;
 export declare const BAR_LIST_TRACK_HEIGHT = 6;
+/** Header text (`fontSizes.sm` line height) + row gap (`space[1]`) + track — a floor, not a hard
+ *  clip, so `VirtualList`'s `itemHeight` gets a real offset hint without constraining content. */
+export declare const BAR_LIST_ROW_HEIGHT = 30;
 export interface BarListColors {
     readonly label: string;
     readonly valueColor: string;
@@ -99,6 +103,21 @@ export declare function resolveBarChartDomain(data: readonly BarChartDomainInput
     min: number;
     max: number;
 };
+/** Per-`useDeviceTier()` cap on rendered categories — scaled down from `MAX_RENDERED_POINTS` (200)
+ *  since each `BarChart` category costs THREE svg nodes (bar, label, press target) against a line
+ *  series' one-per-sample, so the same node budget affords fewer categories on the low tiers. */
+export declare const MAX_RENDERED_CATEGORIES_LOW = 60;
+export declare const MAX_RENDERED_CATEGORIES_MID = 120;
+export declare const MAX_RENDERED_CATEGORIES_HIGH = 200;
+export declare function maxRenderedCategories(tier: DeviceTier): number;
+/**
+ * Evenly-spaced stride sampling down to `maxCategories`, first and last category always kept.
+ * Unlike `decimateSeries`' min/max bucketing (built for a numeric y-value), a category has no
+ * "extreme" to preserve — only its label and position — so an even stride keeps the *shown*
+ * categories representative of the full range instead of clustering at one end. Below the cap the
+ * input array is returned as-is (same reference), so a typical chart is byte-identical to before.
+ */
+export declare function decimateCategories<T>(data: readonly T[], maxCategories: number): readonly T[];
 export interface BarChartSummaryDatum {
     readonly label: string;
     readonly values: readonly number[];
@@ -120,8 +139,17 @@ export declare function resolveLineDomain(series: readonly LineSeriesDomainInput
     max: number;
 };
 /** Above this sample count, line/sparkline series are decimated before any geometry is built —
- *  one svg node per sample is what makes a 5,000-point series unusable on a mid-tier phone. */
+ *  one svg node per sample is what makes a 5,000-point series unusable on a mid-tier phone. Equal
+ *  to `maxRenderedPoints("high")` — kept as a named export since it's also `decimateSeries`'
+ *  default `maxPoints`, for a caller that decimates without a device tier in hand. */
 export declare const MAX_RENDERED_POINTS = 200;
+/** Per-`useDeviceTier()` cap on rendered line/sparkline points. A point costs ONE svg node versus a
+ *  `BarChart` category's three (bar, label, press target), so the same low/mid-tier node budget
+ *  affords more points than `MAX_RENDERED_CATEGORIES` at the same tier. */
+export declare const MAX_RENDERED_POINTS_LOW = 80;
+export declare const MAX_RENDERED_POINTS_MID = 140;
+export declare const MAX_RENDERED_POINTS_HIGH = 200;
+export declare function maxRenderedPoints(tier: DeviceTier): number;
 /**
  * Min/max bucket decimation down to ~`maxPoints`: both endpoints are kept, and the interior is
  * split into equal buckets that each contribute their lowest and highest sample, in original

package/lib/typescript/modules/chip/Chip.d.ts

@@ -8,12 +8,14 @@
  */
 import type { IconName } from "../../core/icon";
 import type { LayoutStyle } from "../../core/style";
-import type { ChipSize, ChipTone, ChipVariant } from "./Chip.variants";
+import type { ChipSize, ChipTone, ChipVariant, CustomToneColors } from "./Chip.variants";
 export interface ChipProps {
     /** A chip is never icon-only — this is its whole accessible name. */
     label: string;
     variant?: ChipVariant;
     tone?: ChipTone;
+    /** Required when `tone="custom"`. */
+    customColors?: CustomToneColors;
     size?: ChipSize;
     /** Renders the filled/accented look regardless of `variant`. Only added to
      *  `accessibilityState` when passed — see `resolveChipAccessibility`. */

package/lib/typescript/modules/chip/Chip.variants.d.ts

@@ -14,7 +14,11 @@ import type { RoleColors, StatusRole, Theme } from "../../theme/hooks";
 export type ChipVariant = "solid" | "outline" | "subtle";
 /** `accent`/`neutral` are brand-driven emphasis; the rest mirror the theme's status roles — same
  *  shape `Badge`'s own `BadgeTone` uses. */
-export type ChipTone = "accent" | "neutral" | StatusRole;
+export type ChipTone = "accent" | "neutral" | StatusRole | "custom";
+export type CustomToneColors = {
+    readonly bg: string;
+    readonly fg: string;
+};
 export type ChipSize = "sm" | "md";
 export type ChipGroupGap = "sm" | "md";
 /** Same touch-target floor as every interactive control in this library (44dp — Apple HIG minimum,
@@ -83,7 +87,7 @@ export interface ChipColors {
  * pair `variant="solid"` reads — so "selected outline chip" and "solid chip" render identically
  * instead of introducing a third, separately-measured filled pairing.
  */
-export declare function resolveChipColors(colors: RoleColors, tone: ChipTone, variant: ChipVariant, selected: boolean): ChipColors;
+export declare function resolveChipColors(colors: RoleColors, tone: ChipTone, variant: ChipVariant, selected: boolean, customColors?: CustomToneColors): ChipColors;
 /** Whether a (variant, selected) combination renders the filled/accented look — the same predicate
  *  `resolveChipColors` and `Chip.tsx`'s own press-feedback branch both key off. */
 export declare function isChipFilled(variant: ChipVariant, selected: boolean): boolean;

package/lib/typescript/modules/chip/index.d.ts

@@ -7,6 +7,6 @@ export { Chip } from "./Chip";
 export type { ChipProps } from "./Chip";
 export { ChipGroup } from "./ChipGroup";
 export type { ChipGroupProps } from "./ChipGroup";
-export type { ChipGroupGap, ChipSize, ChipTone, ChipVariant } from "./Chip.variants";
+export type { ChipGroupGap, ChipSize, ChipTone, ChipVariant, CustomToneColors } from "./Chip.variants";
 export type { IconName } from "../../core/icon";
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/combobox/Combobox.variants.d.ts

@@ -73,6 +73,15 @@ export declare function normalizeForSearch(value: string): string;
  * `role` verbatim, and native maps roles it doesn't know to nothing.
  */
 export declare const COMBOBOX_LISTBOX_ROLE: AccessibilityRole;
+/**
+ * Each option row's role. `aria-selected` is only valid ARIA on `option`/`row`/`tab`/`gridcell`/
+ * `treeitem` — the row sits inside a `COMBOBOX_LISTBOX_ROLE` container, so `option` is the
+ * textbook-correct pairing (2026-08 sweep fixed the row from the invalid `menuitem`+`aria-selected`
+ * combination — a followup to `select/Select.tsx`'s identical fix, both listbox/option/aria-selected
+ * per the ARIA 1.2 combobox-with-listbox-popup pattern). Same type gap as `COMBOBOX_LISTBOX_ROLE`:
+ * RN 0.86's `AccessibilityRole` union has no `option` either.
+ */
+export declare const COMBOBOX_OPTION_ROLE: AccessibilityRole;
 /**
  * The DOM id of one option row. `aria-activedescendant` and `nativeID` must agree exactly, and
  * every `aria-*` prop is UNCHECKED by TypeScript on an RN component (hyphenated JSX attributes are
@@ -136,6 +145,8 @@ export interface ComboboxRowColors {
     /** The option `description` line, the search placeholder, and the empty-state message — all the
      *  muted-text pairings, sharing one measured rung. */
     readonly muted: string;
+    /** Hint ink for the row's own field — a hint, not body copy. */
+    readonly placeholder: string;
     /** Leading option icon, the search glyph, and the clear-row icon. */
     readonly icon: string;
     /** The selected row's "check" glyph. Same value as `text`: if the label clears the stricter 4.5:1
@@ -171,7 +182,7 @@ export interface ComboboxRowAccessibilityInput {
     readonly disabled: boolean;
 }
 export interface ComboboxRowAccessibilityProps {
-    readonly accessibilityRole: "menuitem";
+    readonly accessibilityRole: AccessibilityRole;
     /** Flat, never `accessibilityState`: react-native-web discards the object form (see
      *  `docs/PLATFORM-A11Y-PROPS.md`). Quoted keys so the compiler still checks the prop names. */
     readonly "aria-selected": boolean;
@@ -179,9 +190,11 @@ export interface ComboboxRowAccessibilityProps {
     readonly disabled: boolean;
 }
 /**
- * Every row is `menuitem` (matching this library's `Menu`), in BOTH single and multiple mode — the
- * spec this module was built against fixes this role regardless of mode, unlike `MultiSelect`'s own
- * `checkbox` rows. Selection state rides `aria-selected`, never `aria-checked`.
+ * Every row is `option` (2026-08 sweep — was `menuitem`, which made `aria-selected` invalid ARIA;
+ * the row sits inside `COMBOBOX_LISTBOX_ROLE`, so `option` is the textbook-correct pairing), in BOTH
+ * single and multiple mode: this module's `aria-activedescendant` pattern is one listbox regardless
+ * of mode, unlike `MultiSelect`'s own separate `checkbox` rows. Selection state rides `aria-selected`,
+ * never `aria-checked`.
  */
 export declare function resolveComboboxRowAccessibility(input: ComboboxRowAccessibilityInput): ComboboxRowAccessibilityProps;
 /**

package/lib/typescript/modules/data-table/DataTable.variants.d.ts

@@ -47,7 +47,7 @@ export interface DataTableColors {
      *  minimum clears the icon's 3:1 non-text minimum for free (Menu/Select's identical argument). */
     readonly headerIcon: string;
     /** The header/body boundary — `border.interactive` (≥ 3:1, WCAG 1.4.11), not the decorative
-     *  `border.default`, which is a ~1.2:1 hairline on every brand. */
+     *  `border.default`, which is a ~1.2:1 StyleSheet.hairlineWidth on every brand. */
     readonly headerBorder: string;
     /** Even-row fill. */
     readonly rowBackground: string;

package/lib/typescript/modules/date-picker/DatePicker.variants.d.ts

@@ -263,6 +263,20 @@ export interface DateFieldAccessibilityProps {
  * is folded into the field's own accessible name — the same fallback `Input`/`Select` make.
  */
 export declare function resolveDateFieldAccessibility(input: DateFieldAccessibilityInput): DateFieldAccessibilityProps;
+export interface PressedAccessibilityState {
+    /** The WEB half of "this is the chosen value". Every `role="button"` option this module renders
+     *  (a day cell, a quick-jump month, an hour/minute/meridiem) reports its chosen state through
+     *  `aria-pressed` — `aria-selected` is invalid on `role="button"` and browsers ignore it, same fix
+     *  `chip`'s filter toggle uses. More than one option can be pressed at once (a date range's two
+     *  endpoints); nothing in `aria-pressed` requires the mutual exclusivity a radio group would. */
+    readonly "aria-pressed": boolean;
+    /** The NATIVE half — react-native-web discards the object form, so no invalid `aria-selected`
+     *  reaches the DOM; native accessibility has no "pressed" state, so `selected` is the nearest. */
+    readonly accessibilityState: {
+        readonly selected: boolean;
+    };
+}
+export declare function resolvePressedAccessibilityState(selected: boolean): PressedAccessibilityState;
 export interface CalendarDayAccessibilityInput {
     readonly date: Date;
     readonly selected: boolean;
@@ -272,12 +286,10 @@ export interface CalendarDayAccessibilityInput {
     readonly today?: boolean | undefined;
     readonly locale?: string | undefined;
 }
-export interface CalendarDayAccessibilityProps {
+export interface CalendarDayAccessibilityProps extends PressedAccessibilityState {
     readonly accessibilityRole: "button";
     /** The FULL readable date — a screen reader announcing "15" tells the user nothing. */
     readonly accessibilityLabel: string;
-    /** Flat, not `accessibilityState`: react-native-web discards the object form entirely. */
-    readonly "aria-selected": boolean;
     readonly "aria-disabled": boolean;
 }
 /** Appended to a day's label when the grid conveys the state with colour only (WCAG 1.4.1). */

package/lib/typescript/modules/date-picker/TimePicker.d.ts

@@ -1,10 +1,5 @@
 /**
- * TimePicker — hour / minute (/ AM-PM) selection as independent scrollable columns, never an analog
- * clock face. Hour and minute are virtualized `FlatList`s (Select's precedent — a minute column can
- * hold up to 60 rows); the two-item AM/PM column is a plain view, matching Tabs' own choice not to
- * virtualize a handful of items.
- *
- * All arithmetic (12/24-hour conversion, AM/PM flip, option lists) lives in `DatePicker.variants.ts`.
+ * TimePicker — hour / minute (/ AM-PM) selection columns.
  */
 import type { LayoutStyle } from "../../core/style";
 export interface TimePickerProps {
@@ -12,7 +7,6 @@ export interface TimePickerProps {
     onChange: (date: Date) => void;
     use24Hour?: boolean;
     minuteStep?: number;
-    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
     style?: LayoutStyle;
     testID?: string;
 }

package/lib/typescript/modules/divider/Divider.variants.d.ts

@@ -1,6 +1,6 @@
 /**
  * Divider's style resolution — same split as `Card.variants` / `Button.variants`:
- *  - STRUCTURE (the hairline's thickness on the cross axis) lives in the themed `dividerStructure`
+ *  - STRUCTURE (the StyleSheet.hairlineWidth's thickness on the cross axis) lives in the themed `dividerStructure`
  *    resolver, static per (brand, mode), registered once via `StyleSheet.create`.
  *  - COLOUR is resolved from the theme's ROLE colours by `resolveDividerColor`, never a raw ramp
  *    and never a hardcoded hex.
@@ -23,18 +23,18 @@ export type DividerOrientation = "horizontal" | "vertical";
  */
 export declare function resolveDividerColor(colors: RoleColors): string;
 /**
- * Structural styles only — the hairline's thickness on the theme's `borderWidths` scale, spanning
+ * Structural styles only — the StyleSheet.hairlineWidth's thickness on the theme's `borderWidths` scale, spanning
  * the full cross axis. No colour (resolved separately, applied inline over this), so this compiles
  * once per theme identity via the `WeakMap`-cached themed resolver and never rebuilds per render.
  */
 export declare const dividerStructure: import("../../core/style").ThemedVariantResolver<Theme, {
     orientation: {
         horizontal: {
-            height: 1;
+            height: number;
             width: "100%";
         };
         vertical: {
-            width: 1;
+            width: number;
             alignSelf: "stretch";
         };
     };

package/lib/typescript/modules/empty-state/EmptyState.d.ts

@@ -24,6 +24,8 @@ export interface EmptyStateProps {
     title: string;
     description?: string;
     action?: EmptyStateAction;
+    /** Expands to fill and centre in a flex parent (e.g. a list empty slot). */
+    fill?: boolean;
     /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
     style?: LayoutStyle;
     testID?: string;

package/lib/typescript/modules/empty-state/EmptyState.variants.d.ts

@@ -46,4 +46,5 @@ export declare function resolveEmptyStateAnnouncement(title: string, description
  * never rebuilds per render.
  */
 export declare const emptyStateStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const emptyStateFillStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
 //# sourceMappingURL=EmptyState.variants.d.ts.map

package/lib/typescript/modules/fab/Fab.variants.d.ts

@@ -64,6 +64,8 @@ export interface FabToneColors {
  * lookups, so it inverts light↔dark for free and can never be an off-palette value an app invented.
  */
 export declare function resolveFabTone(colors: RoleColors, tone: FabTone): FabToneColors;
+/** Press scrim direction, chosen by brightness — shared by `Fab` and `FabGroup`'s trigger. */
+export declare function fabOverlayColor(onFill: string): string;
 export interface FabAccessibilityInput {
     readonly label?: string | undefined;
     readonly accessibilityLabel?: string | undefined;

package/lib/typescript/modules/folder-row/FolderRow.d.ts

@@ -1,12 +1,5 @@
 /**
  * FolderRow — file-browser style row with optional leading icon and trailing meta text.
- *
- * It is rendered AS a list cell at scale, so it carries no mount animation and no loop: press
- * feedback is a plain pressed background colour. Colours and style arrays are memoized so a
- * parent re-render with unchanged props costs nothing.
- *
- * Keyboard/AT focus draws an INSET ring (WCAG 2.4.7) rather than the gap-outside ring `Button` uses
- * — a full-bleed row's outset ring is clipped by the list it sits in.
  */
 import type { IconName } from "../../core/icon";
 import type { LayoutStyle } from "../../core/style";
@@ -16,7 +9,6 @@ export interface FolderRowProps {
     icon?: IconName;
     trailing?: string;
     onPress?: () => void;
-    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
     style?: LayoutStyle;
     testID?: string;
 }

package/lib/typescript/modules/gantt/Gantt.variants.d.ts

@@ -2,6 +2,7 @@
  * Gantt layout math — ported from tickets/mobile EpicTimeline. Pure, testable.
  */
 import type { RoleColors } from "../../theme/hooks";
+import type { DeviceTier } from "../../core/device";
 export declare const MS_PER_DAY = 86400000;
 export declare const GANTT_LABEL_W = 108;
 export declare const GANTT_ROW_H = 46;
@@ -13,6 +14,13 @@ export declare const GANTT_MIN_SPAN_MS: number;
 export declare const GANTT_PAD_MS: number;
 /** WCAG 2.5.5 target size, the library-wide floor (`Tabs`/`Pagination`/`Reorder` all pin the same 44). */
 export declare const MIN_TOUCH_TARGET = 44;
+/**
+ * Lanes rendered before the "show all" affordance takes over — the same worst-case safety valve as
+ * `MAX_RENDERED_POINTS` in `Charts.variants.ts`, tier-scaled because a lane count this large comes
+ * from real ticket/epic data (this component's own documented origin), not a series a caller could
+ * decimate without losing rows a reader actually needs.
+ */
+export declare const MAX_RENDERED_LANES: Readonly<Record<DeviceTier, number>>;
 /**
  * A bar is a *data mark* — its 18dp height encodes nothing but the chart's row rhythm, and its width
  * encodes the lane's duration, so neither can be grown to 44dp without lying about the data. When
@@ -79,4 +87,17 @@ export interface GanttColors {
  */
 export declare function resolveGanttColors(colors: RoleColors): GanttColors;
 export declare function computeGanttModel(lanes: readonly GanttLaneInput[], windowWidth: number, nowMs: number): GanttModel;
+export interface GanttVisibleLanes {
+    readonly lanes: readonly GanttLaneLayout[];
+    readonly bodyHeight: number;
+    readonly totalCount: number;
+    readonly hiddenCount: number;
+}
+/**
+ * Slices the already-laid-out lanes to `maxLanes` unless `expanded`. Safe to slice AFTER
+ * `computeGanttModel`: each lane's `leftPx`/`widthPx` is derived from the shared time domain, not
+ * from its position in the array, so dropping trailing lanes never shifts the ones kept. `bodyHeight`
+ * is recomputed for the slice so the chart body and the "today" line never overshoot the rendered rows.
+ */
+export declare function resolveVisibleGanttLanes(model: GanttModel, maxLanes: number, expanded: boolean): GanttVisibleLanes;
 //# sourceMappingURL=Gantt.variants.d.ts.map