pixelize-native-library 1.0.7 → 1.2.1

package/lib/typescript/modules/textarea/Textarea.variants.d.ts

@@ -11,7 +11,7 @@
  * Free of React and of any lucide import, so the WCAG + behaviour tests import it directly (mocking
  * only `react-native`'s `StyleSheet`, as `core/style` does).
  */
-import type { RoleColors, Theme } from "../../theme";
+import type { RoleColors, Theme } from "../../theme/hooks";
 export type TextareaSize = "sm" | "md" | "lg";
 export type TextareaStatus = "default" | "error";
 /**
@@ -56,24 +56,31 @@ export interface TextareaStatusColors {
 export declare function resolveTextareaStatus(colors: RoleColors, status: TextareaStatus): TextareaStatusColors;
 export interface TextareaAccessibilityInput {
     readonly label?: string | undefined;
+    readonly accessibilityLabel?: string | undefined;
     readonly helperText?: string | undefined;
     readonly errorText?: string | undefined;
     readonly status?: TextareaStatus | undefined;
     readonly disabled?: boolean | undefined;
 }
 export interface TextareaAccessibilityProps {
+    /** The visible label (or an explicit override), with `errorText` appended in the error state. */
     readonly accessibilityLabel: string | undefined;
-    /** The message actually shown — `errorText` when in error status (if provided), else `helperText`. */
+    /** ADVISORY supporting text only (`helperText`). Never the validity message. */
     readonly accessibilityHint: string | undefined;
-    readonly accessibilityState: {
-        readonly disabled: boolean;
-    };
+    readonly "aria-invalid": boolean;
+    readonly "aria-disabled": boolean;
+    /** The string the component renders below the field — `errorText` in the error state, else `helperText`. */
+    readonly message: string | undefined;
 }
 /**
  * Derives the accessibility surface once, purely, so the label/hint/disabled contract is testable
- * without a renderer. React Native has no `aria-describedby`; `accessibilityHint` is the platform
- * equivalent, so the SAME string this returns is also what the component renders as the visible
- * helper/error `Text` — one source of truth, never two strings that could drift apart.
+ * without a renderer.
+ *
+ * Same split as `resolveInputAccessibility`, for the same reason: a validity message must not ride
+ * `accessibilityHint`, because a hint is advisory and some readers suppress it (the rule
+ * `resolveFormFieldAccessibility` already states). So `errorText` joins the NAME and sets
+ * `aria-invalid`, while the genuinely advisory `helperText` stays on the hint — which the component
+ * additionally links with `aria-describedby` on web, where `accessibilityHint` does not exist.
  */
 export declare function resolveTextareaAccessibility(input: TextareaAccessibilityInput): TextareaAccessibilityProps;
 /**

package/lib/typescript/modules/timeline/Timeline.d.ts

@@ -1,30 +1,26 @@
 /**
- * Timeline — a vertical list of dated/ordered events. Each row is a marker (a plain dot, or an
- * icon in a filled circle) connected to the next row's marker by a line. Purely informational: no
- * press handling, no per-item emphasis, no animation. The marker + connecting line are decorative
- * (removing them changes spacing, not meaning — same reasoning `Divider` documents for its own
- * hairline), so they are hidden from assistive tech; the title/description/timestamp stay in the
- * normal accessibility tree, read in order, exactly like the plain `View` container `Card.tsx`
- * documents ("nothing here for `accessibilityRole` to announce — children carry their own
- * semantics").
+ * Timeline — a vertical list of dated/ordered events.
+ *
+ * The reveal is ONE animated value on the outer container, never one per row: rows are recycled
+ * cells in a `VirtualList`, so a per-cell animation would fire on every scroll-in. It is gated on
+ * `motion.decorative` (high-tier only) since a reveal is pure decoration.
+ *
+ * A row's title, description and timestamp form ONE accessible node — see
+ * `resolveTimelineItemAccessibility` for why three loose `Text` siblings were a 1.3.1 failure.
  */
 import type { ReactNode } from "react";
 import type { IconName } from "../../core/icon";
 import type { LayoutStyle } from "../../core/style";
 export interface TimelineItem {
+    readonly id?: string;
     readonly title: string;
     readonly description?: string;
     readonly timestamp?: string;
-    /** A NAME, never a `ReactNode`. Always paired with the visible `title` — never the sole label of
-     *  anything, so it carries no `accessibilityLabel` requirement of its own. */
     readonly icon?: IconName;
-    /** Rendered in place of the default marker (dot or icon circle). Decorative like the marker it
-     *  replaces — it sits inside the AT-hidden connector column. */
     readonly leading?: ReactNode;
 }
 export interface TimelineProps {
     items: TimelineItem[];
-    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
     style?: LayoutStyle;
     testID?: string;
 }

package/lib/typescript/modules/timeline/Timeline.variants.d.ts

@@ -11,7 +11,7 @@
  * Free of React and of any lucide import, so the WCAG + colour-mapping tests import it directly
  * (mocking only `react-native`'s `StyleSheet`, as `core/style` and every sibling module's tests do).
  */
-import type { RoleColors, Theme } from "../../theme";
+import type { RoleColors, Theme } from "../../theme/hooks";
 export interface TimelineMarkerSpec {
     /** Plain-dot diameter, in dp — used when an item carries no `icon`. */
     readonly dot: number;
@@ -82,6 +82,22 @@ export declare const timelineMarkerStructure: import("../../core/style").ThemedV
  * `timelineContentStructure`), so the line never visibly stops short of the next marker.
  */
 export declare const timelineConnectorLineStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export interface TimelineItemAccessibilityInput {
+    readonly title: string;
+    readonly description?: string;
+    readonly timestamp?: string;
+}
+export interface TimelineItemAccessibilityProps {
+    readonly accessible: true;
+    readonly accessibilityRole: "text";
+    readonly accessibilityLabel: string;
+}
+/**
+ * One event's title, description and timestamp collapse into ONE accessible node (WCAG 1.3.1) — as
+ * three loose `Text` siblings, only their visual grouping said which timestamp belonged to which
+ * title. The same composition `resolveBannerAccessibility` does for its title + message.
+ */
+export declare function resolveTimelineItemAccessibility(item: TimelineItemAccessibilityInput): TimelineItemAccessibilityProps;
 /**
  * The text column beside the connector. A `middle` row (one with a following item) reserves the
  * gap to that next row HERE, on the content sibling, not on the shared row wrapper — a row with an

package/lib/typescript/modules/toast/Toast.d.ts

@@ -13,14 +13,24 @@
  * restarts the auto-dismiss timer (and, since a fresh message reads as a new event, restarts the
  * entrance animation) rather than queueing a second one. `dismiss()` always dismisses that one slot,
  * and is a safe no-op when nothing is showing.
+ *
+ * Auto-dismiss is WCAG 2.2.1 (Timing Adjustable) territory: how long a toast lives is decided ONLY
+ * by `resolveAutoDismissDelay` (persistent mode, the screen-reader suppression, the `danger`
+ * default), and the timer is only armed while the user is neither hovering nor focused inside the
+ * card. Hover/focus pause and re-arm, they never dismiss.
  */
 import type { ReactNode } from "react";
-import type { ToastPosition, ToastTone } from "./Toast.variants";
+import type { ToastDuration, ToastPosition, ToastTone } from "./Toast.variants";
 export interface ToastOptions {
     readonly message: string;
     readonly tone?: ToastTone;
-    /** Auto-dismiss delay in ms. Defaults to `DEFAULT_TOAST_DURATION` (~3000ms). */
-    readonly duration?: number;
+    /**
+     * How long the toast stays up: a delay in ms, or `"persistent"` for "until the user dismisses
+     * it". Omitted means `DEFAULT_TOAST_DURATION` (~3000ms) — except `tone: "danger"`, which is
+     * persistent by default. A running screen reader suppresses auto-dismiss for every tone
+     * (WCAG 2.2.1 — `resolveAutoDismissDelay`).
+     */
+    readonly duration?: ToastDuration;
 }
 export interface ToastContextValue {
     show: (options: ToastOptions) => void;

package/lib/typescript/modules/toast/Toast.variants.d.ts

@@ -12,8 +12,8 @@
  * Free of React and of `lucide`, so the WCAG + behaviour tests import it directly (mocking only
  * `react-native`'s `StyleSheet`, as `core/style` does).
  */
-import type { RoleColors } from "../../theme";
-import type { Theme } from "../../theme";
+import type { RoleColors } from "../../theme/hooks";
+import type { Theme } from "../../theme/hooks";
 export type ToastTone = "success" | "warning" | "danger" | "info" | "neutral";
 export type ToastPosition = "top" | "bottom";
 /** Same floor as Button/Input/Checkbox — 44dp (WCAG 2.5.5 / HIG). Duplicated, not imported: modules
@@ -24,8 +24,38 @@ export declare const MIN_TOUCH_TARGET = 44;
 export declare const CLOSE_BUTTON_SIZE = 24;
 export declare const CLOSE_ICON_SIZE = 16;
 export declare const CLOSE_HIT_SLOP: number;
-/** `duration?: number` on `ToastOptions` defaults to this when omitted. */
+/** `duration` on `ToastOptions` defaults to this when omitted — except for `danger` (see below). */
 export declare const DEFAULT_TOAST_DURATION = 3000;
+export declare const TOAST_IOS_HOME_INDICATOR_INSET = 20;
+export declare function resolveToastBottomInset(basePadding: number, platformOS: string): number;
+/**
+ * How long a toast stays up. `"persistent"` = until the user dismisses it (or a later `show()`
+ * replaces it) — spelled out rather than encoded as a number, because a bare `0` at a call site
+ * reads as "no delay", not "forever".
+ */
+export type ToastDuration = number | "persistent";
+/** `setTimeout`'s delay is a 32-bit signed int; a larger value wraps and fires almost immediately. */
+export declare const MAX_TIMEOUT_MS = 2147483647;
+/**
+ * WCAG 2.2.1 (Timing Adjustable) — resolves a requested duration into a real `setTimeout` delay, or
+ * `null` for "never auto-dismiss". `Toast.tsx` branches on `null` BEFORE arming the timer; nothing
+ * else in the module decides how long a toast lives.
+ *
+ * Three rules, in order:
+ *
+ * 1. **`"persistent"`, and every unusable number, mean forever.** `0`, negatives and `NaN` used to
+ *    slip past a `?? DEFAULT_TOAST_DURATION` fallback (only `null`/`undefined` are nullish) and
+ *    became `setTimeout(hide, 0)`; `Infinity` overflowed the 32-bit delay above and fired in ~1ms.
+ *    Both looked like a persistent mode and were an instant-dismiss mode. Failing towards "stays
+ *    up" is the safe direction: the card always has a close button.
+ * 2. **A running screen reader suppresses auto-dismiss entirely.** 3s is not enough to finish
+ *    speaking a message, and there is no way to replay a toast that has gone.
+ * 3. **`danger` with no explicit duration is persistent.** An error the user never finished reading
+ *    is the exact failure 2.2.1 exists to prevent, and this catalogue has no toast history to
+ *    recover it from. An explicit `duration` is still honoured — that is a deliberate caller
+ *    decision, not the default falling on an error message.
+ */
+export declare function resolveAutoDismissDelay(duration: ToastDuration | undefined, tone: ToastTone, screenReaderEnabled: boolean): number | null;
 export interface ToastToneColors {
     /** The card's own background — constant across tones (an elevated, neutral surface). */
     readonly background: string;

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

@@ -8,5 +8,5 @@
  */
 export { ToastProvider, useToast } from "./Toast";
 export type { ToastContextValue, ToastOptions, ToastProviderProps } from "./Toast";
-export type { ToastPosition, ToastTone } from "./Toast.variants";
+export type { ToastDuration, ToastPosition, ToastTone } from "./Toast.variants";
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/toast/toastScreenReader.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tracks whether a screen reader is running, so `ToastProvider` can stop auto-dismissing a message
+ * the reader has not finished speaking (WCAG 2.2.1 — see `resolveAutoDismissDelay`).
+ *
+ * Shaped exactly like `core/a11y`'s `useReducedMotion`: ONE module-level store read through
+ * `useSyncExternalStore`, so the async probe and the native `screenReaderChanged` listener are
+ * opened by the first subscriber and closed when the last one leaves, however many providers mount.
+ * It lives here rather than in `core/a11y` only because that folder is owned by another change in
+ * flight — it is a `core/a11y` concern and should move there (`MODULE.md` → Known gaps).
+ *
+ * **It seeds `false`, unlike `useReducedMotion`'s pessimistic `true`.** The two hooks are read at
+ * different moments: a reduce-motion gate runs in the same commit as the mount that opens the probe,
+ * so it must assume the worst, whereas this is read by `show()` — a user-initiated event, long after
+ * `ToastProvider` mounted at the app root and the probe answered. Seeding `true` would instead make
+ * every toast in the first frames of an app run persistent for a sighted user, which is the more
+ * visible failure and the less likely one to be true.
+ */
+/** Test-only: drops the process cache and re-probes, so a suite can drive both answers. */
+export declare function resetScreenReaderCache(): void;
+/** Live OS screen-reader state (VoiceOver / TalkBack), one probe and one listener per process. */
+export declare function useScreenReaderEnabled(): boolean;
+//# sourceMappingURL=toastScreenReader.d.ts.map

package/lib/typescript/modules/tooltip/Tooltip.d.ts

@@ -1,28 +1,51 @@
 /**
- * Tooltip — wraps a single trigger element and reveals a short themed tip on long-press, without
- * requiring the trigger to know anything about it. No `style` prop: unlike the other modules,
- * Tooltip renders no sized node of its own for an app to place — the trigger child keeps whatever
- * layout it already has, and the wrapping host below exists only to anchor the bubble.
+ * Tooltip — wraps a single trigger element and reveals a short themed tip on hover (pointer),
+ * focus (keyboard) or long-press (touch), without requiring the trigger to know anything about it.
+ * No `style` prop: unlike the other modules, Tooltip renders no sized node of its own for an app to
+ * place — the trigger child keeps whatever layout it already has, and the wrapping host below
+ * exists only to anchor the bubble.
  *
- * Composition is `React.cloneElement` on the single child, never `{...rest}`: `onLongPress` and
- * `onPressOut` are injected (chaining any handler the child already defined, so Tooltip never
- * silently breaks a trigger that already used them), and `accessibilityHint` is MERGED via
- * `mergeAccessibilityHint` — the one prop that must never be clobbered, since it is how a
- * screen-reader user gets the tip's content without performing the gesture at all.
+ * Composition is `React.cloneElement` on the single child, never `{...rest}`: `onLongPress`,
+ * `onPressOut`, `onHoverIn`, `onHoverOut`, `onFocus` and `onBlur` are injected (each chaining any
+ * handler the child already defined, so Tooltip never silently breaks a trigger that already used
+ * them), and `accessibilityHint` is MERGED via `mergeAccessibilityHint` — the one prop that must
+ * never be clobbered, since it is how a screen-reader user gets the tip's content without
+ * performing the gesture at all.
+ *
+ * That hint reaches NOTHING on web — react-native-web has no `accessibilityHint` at all — so the
+ * bubble additionally carries an `id` and the trigger points `aria-describedby` at it while the tip
+ * is mounted. The bubble stays `aria-hidden` in both worlds: an `aria-describedby` target is read
+ * through the reference even when hidden, so this describes the trigger once instead of twice.
+ *
+ * The hover/focus pair is injected on every platform rather than behind a `Platform.OS === "web"`
+ * branch: `Pressable` accepts all four props everywhere, and only react-native-web actually emits
+ * them, so a branch would buy nothing but a cast.
+ *
+ * The bubble's reveal is the shared `useEnterExit` preset (`core/motion`): fade + a short settle,
+ * kept mounted by a timer rather than an animation callback, so an interrupted fade-out can never
+ * strand the bubble in the tree.
  */
 import type { ReactElement } from "react";
-import type { GestureResponderEvent } from "react-native";
+import type { GestureResponderEvent, MouseEvent, NativeSyntheticEvent, TargetedEvent } from "react-native";
 import type { TooltipPlacement } from "./Tooltip.variants";
 /** The subset of props Tooltip reads from / injects into its trigger child. */
 export interface TooltipTriggerProps {
     onLongPress?: (event: GestureResponderEvent) => void;
     onPressOut?: (event: GestureResponderEvent) => void;
+    onHoverIn?: (event: MouseEvent) => void;
+    onHoverOut?: (event: MouseEvent) => void;
+    onFocus?: (event: NativeSyntheticEvent<TargetedEvent>) => void;
+    onBlur?: (event: NativeSyntheticEvent<TargetedEvent>) => void;
     accessibilityHint?: string;
+    "aria-describedby"?: string;
 }
 export interface TooltipProps {
     /** The tip's text. Also what gets merged into the trigger's `accessibilityHint`. */
     label: string;
-    /** A single element that accepts `onLongPress`/`onPressOut` (e.g. a `Pressable`). */
+    /**
+     * A single element that accepts the press/hover/focus handlers Tooltip injects (e.g. a
+     * `Pressable`). A `Text` is not enough: on web it renders a plain element that emits none of them.
+     */
     children: ReactElement<TooltipTriggerProps>;
     placement?: TooltipPlacement;
     testID?: string;

package/lib/typescript/modules/tooltip/Tooltip.variants.d.ts

@@ -11,17 +11,23 @@
  * Free of `lucide` and of any React tree, so the WCAG + behaviour tests import it directly
  * (mocking only `react-native`'s `StyleSheet`, as `core/style` does).
  */
-import type { Theme } from "../../theme";
+import type { Theme } from "../../theme/hooks";
 export type TooltipPlacement = "top" | "bottom";
 /**
- * Design constants, not theme tokens — this module's own timing, not a scale other components
- * share.
+ * A dwell time, not a transition: how long a tip may stay up on its own. The fade itself has no
+ * constant here — duration, easing and the reduced-motion contract all come from the global motion
+ * system (`core/motion`).
  */
 export declare const TOOLTIP_TIMING: {
-    /** Fade-in duration; skipped (duration 0) when the OS reduce-motion setting is on (WCAG 2.3.3). */
-    readonly fadeInMs: 150;
     /** Fallback auto-dismiss so a tip can't stay stuck open if `onPressOut` never fires. */
     readonly autoHideMs: 2500;
+    /**
+     * Grace period before a hover-out actually hides the bubble, so a pointer crossing the
+     * `theme.space[1]` gap to the bubble itself doesn't lose the tip mid-transit (WCAG 1.4.13
+     * hoverable). The CSS/UI convention for this exact case; entering the bubble before it elapses
+     * cancels the hide.
+     */
+    readonly hoverOutGraceMs: 200;
 };
 /**
  * Appends `label` to any `accessibilityHint` the trigger already carries, so screen-reader users

package/lib/typescript/modules/typing-indicator/TypingIndicator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * TypingIndicator — three animated dots for "someone is typing". Under reduced motion, and on any
+ * tier that can't afford decorative motion, the dots are static (WCAG 2.3.3) — the accessible
+ * "Typing" label is the real signal, exactly as `Spinner` treats its own frozen glyph.
+ *
+ * The consumer mounts and unmounts this component as typing starts and stops, so "Typing" is spoken
+ * ONCE per mount via `useAnnounce` (WCAG 4.1.3) — not on a timer, and not once per pulse: the effect
+ * fires once per mounted instance, and `useAnnounce`'s own dedup would silence a repeat regardless.
+ * A screen-reader user who is not focused on the thread would otherwise learn someone is typing only
+ * by chance, on their next swipe past this element.
+ *
+ * Each dot loops a BARE `motion.timing` over a 0→1 driver and interpolates that into the
+ * min→max→min opacity pulse. `Animated.loop` only runs natively (`_startNativeLoop`) when the
+ * animation it wraps reports `_isUsingNativeDriver()`, which `Animated.sequence` returns `false`
+ * for unconditionally — a looped sequence therefore restarts every leg from the JS thread, forever.
+ * The stagger is `TimingOptions.delay` (one JS timeout per dot at start-up) rather than
+ * `Animated.delay`, which is itself a `useNativeDriver: false` timing.
+ */
+import type { LayoutStyle } from "../../core/style";
+import type { TypingIndicatorSize } from "./TypingIndicator.variants";
+export interface TypingIndicatorProps {
+    size?: TypingIndicatorSize;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+export declare const TypingIndicator: import("react").NamedExoticComponent<TypingIndicatorProps>;
+//# sourceMappingURL=TypingIndicator.d.ts.map

package/lib/typescript/modules/typing-indicator/TypingIndicator.variants.d.ts

@@ -0,0 +1,32 @@
+import type { Theme } from "../../theme/hooks";
+export type TypingIndicatorSize = "sm" | "md";
+export declare const TYPING_DOT_SIZES: {
+    readonly sm: 6;
+    readonly md: 8;
+};
+export declare const TYPING_DOT_MIN_OPACITY = 0.3;
+export declare const TYPING_DOT_MAX_OPACITY = 1;
+export declare const typingIndicatorStructure: import("../../core/style").ThemedVariantResolver<Theme, {
+    size: {
+        sm: {};
+        md: {};
+    };
+}, import("react-native").ViewStyle>;
+export declare const typingDotStructure: import("../../core/style").ThemedVariantResolver<Theme, {
+    size: {
+        sm: {
+            width: 6;
+            height: 6;
+        };
+        md: {
+            width: 8;
+            height: 8;
+        };
+    };
+}, import("react-native").ViewStyle>;
+export declare function resolveTypingIndicatorAccessibility(): {
+    readonly accessible: true;
+    readonly accessibilityRole: "text";
+    readonly accessibilityLabel: string;
+};
+//# sourceMappingURL=TypingIndicator.variants.d.ts.map

package/lib/typescript/modules/typing-indicator/index.d.ts

@@ -0,0 +1,4 @@
+export { TypingIndicator } from "./TypingIndicator";
+export type { TypingIndicatorProps } from "./TypingIndicator";
+export type { TypingIndicatorSize } from "./TypingIndicator.variants";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/unread-badge/UnreadBadge.d.ts

@@ -0,0 +1,15 @@
+/**
+ * UnreadBadge — a compact count pill for chat/notification overflow ("9+"). Renders nothing when
+ * `count` is 0. Positioned by the consumer (typically absolute on an icon parent).
+ */
+import type { LayoutStyle } from "../../core/style";
+import type { UnreadBadgeSize } from "./UnreadBadge.variants";
+export interface UnreadBadgeProps {
+    count: number;
+    size?: UnreadBadgeSize;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+export declare const UnreadBadge: import("react").NamedExoticComponent<UnreadBadgeProps>;
+//# sourceMappingURL=UnreadBadge.d.ts.map

package/lib/typescript/modules/unread-badge/UnreadBadge.variants.d.ts

@@ -0,0 +1,56 @@
+/**
+ * UnreadBadge style resolution — structure in themed resolvers, colour from role tokens.
+ * Free of React so WCAG tests import directly.
+ */
+import type { RoleColors, Theme } from "../../theme/hooks";
+export type UnreadBadgeSize = "sm" | "md";
+export interface UnreadBadgeSizeSpec {
+    readonly minWidth: number;
+    readonly height: number;
+    readonly fontSize: number;
+    readonly paddingHorizontal: number;
+}
+export declare const UNREAD_BADGE_SIZES: {
+    readonly sm: {
+        readonly minWidth: 16;
+        readonly height: 16;
+        readonly fontSize: 10;
+        readonly paddingHorizontal: 3;
+    };
+    readonly md: {
+        readonly minWidth: 20;
+        readonly height: 20;
+        readonly fontSize: 11;
+        readonly paddingHorizontal: 4;
+    };
+};
+export declare const UNREAD_BADGE_MAX_DISPLAY = 9;
+export declare function formatUnreadCount(count: number): string;
+export interface UnreadBadgeColors {
+    readonly fill: string;
+    readonly text: string;
+}
+export declare function resolveUnreadBadgeColors(colors: RoleColors): UnreadBadgeColors;
+export interface UnreadBadgeAccessibilityInput {
+    readonly count: number;
+}
+export declare function resolveUnreadBadgeAccessibility(input: UnreadBadgeAccessibilityInput): {
+    readonly accessible: true;
+    readonly accessibilityRole: "text";
+    readonly accessibilityLabel: string;
+};
+export declare const unreadBadgeStructure: import("../../core/style").ThemedVariantResolver<Theme, {
+    size: {
+        sm: {
+            minWidth: 16;
+            height: 16;
+            paddingHorizontal: 3;
+        };
+        md: {
+            minWidth: 20;
+            height: 20;
+            paddingHorizontal: 4;
+        };
+    };
+}, import("react-native").ViewStyle>;
+//# sourceMappingURL=UnreadBadge.variants.d.ts.map

package/lib/typescript/modules/unread-badge/index.d.ts

@@ -0,0 +1,4 @@
+export { UnreadBadge } from "./UnreadBadge";
+export type { UnreadBadgeProps } from "./UnreadBadge";
+export type { UnreadBadgeSize } from "./UnreadBadge.variants";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/test/mocks/flashList.d.ts

@@ -0,0 +1,3 @@
+import { FlatList } from 'react-native';
+export declare const FlashList: typeof FlatList;
+//# sourceMappingURL=flashList.d.ts.map

package/lib/typescript/test/perfHelpers.d.ts

@@ -0,0 +1,9 @@
+/** Shared helpers for *.perf.test.tsx — mounted-row bounds and render-count guards. */
+export declare const PERF_DATASET_SIZE = 10000;
+export declare const PERF_MAX_MOUNTED_ROWS = 200;
+export declare function makeIndexedDataset(size: number): ReadonlyArray<{
+    id: string;
+    label: string;
+}>;
+export declare function countByTestIdPrefix(queryAllByTestId: (id: string | RegExp) => unknown[], prefix: string): number;
+//# sourceMappingURL=perfHelpers.d.ts.map

package/lib/typescript/theme/hooks.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Lightweight theme hooks — no PixelizeProvider, no palette barrels.
+ * Component modules import from here instead of the theme barrel.
+ */
+export { useTheme } from './provider/useTheme';
+export { useThemeColors } from './provider/useThemeColors';
+export { useThemeMode } from './provider/useThemeMode';
+export type { Theme, ThemeModeValue } from './provider/types';
+export type { RoleColors, StatusColors, StatusRole } from './tokens/roles';
+export type { ThemeName, ColorScheme, PaletteProps } from './tokens/types';
+//# sourceMappingURL=hooks.d.ts.map

package/lib/typescript/theme/index.d.ts

@@ -3,9 +3,10 @@
  * types a consumer annotates with. Design tokens themselves ship under `pixelize-native-library/tokens`;
  * this subpath is intentionally the small, runtime-facing layer an app wires once at its root.
  */
-export { PixelizeProvider, useTheme, useThemeColors, useThemeMode, createAsyncStorageAdapter, } from './provider';
+export { PixelizeProvider, useTheme, useThemeColors, useThemeMode, createAsyncStorageAdapter, THEME_NAMES, DEFAULT_THEME, loadPalette, loadPaletteSync, } from './provider';
 export type { PixelizeProviderProps, Theme, ThemeModeValue, ThemeMode, ColorModeStorageAdapter, AsyncStorageLike, } from './provider';
 export type { RoleColors, StatusColors, StatusRole } from './tokens/roles';
-export type { ThemeName, ColorScheme, PaletteProps } from './tokens/types';
-export { themeNames, DEFAULT_THEME } from './tokens/brands';
+export type { ThemeName, ColorScheme, PaletteProps, BrandPaletteSource, SemanticTone, SemanticTextTokens, } from './tokens/types';
+/** @deprecated Use THEME_NAMES from this module instead. */
+export { THEME_NAMES as themeNames } from './provider';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/theme/platform/elevation.native.d.ts

@@ -1,35 +1,5 @@
 import type { ViewStyle } from 'react-native';
 import type { ElevationToken } from '../tokens/primitives';
-/**
- * The style props an elevation resolves to. A `Pick` rather than `ViewStyle` so a future RN
- * shadow prop cannot silently widen what this function is allowed to emit.
- */
 export type ElevationStyle = Pick<ViewStyle, 'shadowColor' | 'shadowOffset' | 'shadowOpacity' | 'shadowRadius' | 'elevation'>;
-/**
- * Resolve an elevation token to RN style props.
- *
- * Uses the legacy shadow props over `boxShadow` because `boxShadow` is New-Architecture-only, and
- * our peer range (RN >= 0.79) still lets a consumer ship `newArchEnabled=false` — on which
- * `boxShadow` renders nothing at all. The legacy props map straight to the platform APIs and are
- * not deprecated, so they are the only path that works on both architectures. react-native-web's
- * style preprocessor converts these same legacy props into a real CSS `box-shadow`, so the `web`
- * branch below rides that conversion rather than emitting `boxShadow` itself.
- *
- * An elevation token is a STACK of layers (web needs both an ambient and a contact shadow per
- * step), but legacy RN shadow props can only express one. This renders `layers[0]` — the dominant
- * layer — and drops the rest. That is an honest limit of the legacy path, not a token compromise:
- * a future `boxShadow`-only resolver (new-arch-only consumers) can render every layer.
- *
- * `layer.spread` is dropped — neither legacy platform API exposes it (RN implements it by
- * insetting a custom shadowPath). The ramp's `md`/`lg` carry a negative spread to tighten the
- * shadow on web, so those two steps read marginally wider here. Accepted: honouring it would mean
- * hand-drawing a shadow layer per view.
- *
- * Returns one of three shapes: `ios`, `android` (RN's `default` branch — Android reads the numeric
- * `elevation` prop and ignores offset/opacity/radius), and `web`. `web` MUST stay its own explicit
- * key: without it, react-native-web falls through to `default` (the Android shape), whose only
- * meaningful field — `elevation` — react-native-web silently ignores (it is Android-only), so the
- * shadow renders as nothing at all.
- */
 export declare function elevation(token: ElevationToken): ElevationStyle;
 //# sourceMappingURL=elevation.native.d.ts.map

package/lib/typescript/theme/platform/floatingSurface.native.d.ts

@@ -0,0 +1,10 @@
+import type { ViewStyle } from 'react-native';
+import type { ElevationLevel } from '../tokens';
+import type { Theme } from '../provider/types';
+import type { ElevationToken } from '../tokens/primitives';
+import { type BoxShadowLayer } from './highlight.native';
+export type FloatingLevel = Extract<ElevationLevel, 'sm' | 'md' | 'lg'>;
+export declare function tokenBoxShadow(token: ElevationToken): ReadonlyArray<BoxShadowLayer>;
+export declare function floatingBackground(theme: Theme, level: FloatingLevel): string;
+export declare function floatingSurfaceStyle(theme: Theme, level: FloatingLevel): ViewStyle;
+//# sourceMappingURL=floatingSurface.native.d.ts.map

package/lib/typescript/theme/platform/highlight.native.d.ts

@@ -0,0 +1,17 @@
+import type { ViewStyle } from 'react-native';
+import type { ColorScheme } from '../tokens/types';
+export type HighlightLevel = 'none' | 'subtle' | 'raised';
+export type BoxShadowLayer = {
+    offsetX: number | string;
+    offsetY: number | string;
+    blurRadius?: number | string;
+    spreadDistance?: number | string;
+    inset?: boolean;
+    color?: string;
+};
+export type BoxShadowArray = ReadonlyArray<BoxShadowLayer>;
+export declare function highlightLevels(level: HighlightLevel, mode: ColorScheme): BoxShadowArray;
+export declare function highlight(level: HighlightLevel, mode: ColorScheme): BoxShadowArray;
+export declare function composeBoxShadow(outset: ReadonlyArray<BoxShadowLayer>, inset: BoxShadowArray): BoxShadowArray;
+export declare function asBoxShadowArray(value: ViewStyle['boxShadow']): ReadonlyArray<BoxShadowLayer>;
+//# sourceMappingURL=highlight.native.d.ts.map

package/lib/typescript/theme/platform/index.d.ts

@@ -8,6 +8,15 @@
 export { rem, hairline } from './units.native';
 export { elevation } from './elevation.native';
 export type { ElevationStyle } from './elevation.native';
+export { highlight, highlightLevels, composeBoxShadow } from './highlight.native';
+export type { HighlightLevel } from './highlight.native';
+export { elevatedSurfaces } from './surfaces.native';
+export type { ElevatedSurfaceRoles } from './surfaces.native';
+export { STATE_LAYER_OPACITY, rippleColor, stateLayerScrim } from './stateLayer.native';
+export { floatingBackground, floatingSurfaceStyle } from './floatingSurface.native';
+export type { FloatingLevel } from './floatingSurface.native';
+export { springs } from './motion.native';
+export type { SpringConfig, SpringKey } from './motion.native';
 export { interFontFamilies, systemFontFamily, fontStyleForWeight } from './fonts.native';
 export type { FontWeightValue, FontStyleForWeight } from './fonts.native';
 export { getSystemColorMode, subscribeToSystemColorMode } from './colorScheme.native';