pixelize-native-library 1.0.7 → 1.2.0

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

@@ -3,6 +3,9 @@
  * does not depend on it). Same closed-prop shape the rest of the catalogue follows: `size` / `status`
  * are closed unions, colour is resolved from `RoleColors`, and `containerStyle` is the one documented
  * `LayoutStyle` exception for a component wrapping a native `TextInput` (CLAUDE.md).
+ *
+ * Motion comes from `core/motion`: the focus ring crossfades and the helper/error message fades in
+ * and out, both gated by `useMotion()`'s reduce-motion resolution.
  */
 import type { LayoutStyle } from "../../core/style";
 import type { TextareaSize, TextareaStatus } from "./Textarea.variants";
@@ -14,6 +17,8 @@ export interface TextareaProps {
     status?: TextareaStatus;
     disabled?: boolean;
     label?: string;
+    /** Overrides the label→`accessibilityLabel` fallback, for a field whose visible label is elsewhere. */
+    accessibilityLabel?: string;
     helperText?: string;
     errorText?: string;
     maxLength?: number;

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,36 @@ 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;
+/**
+ * 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,15 +11,14 @@
  * 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;
 };

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';
+/** @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/motion.native.d.ts

@@ -0,0 +1,15 @@
+export declare const motionDurations: {
+    readonly instant: 0;
+    readonly fast: 150;
+    readonly normal: 200;
+    readonly slow: 300;
+};
+export declare const motionEasings: {
+    standard: "ease-in-out";
+    enter: "ease-out";
+    exit: "ease-in";
+    snap: "linear";
+};
+export type MotionDuration = keyof typeof motionDurations;
+export type MotionEasing = keyof typeof motionEasings;
+//# sourceMappingURL=motion.native.d.ts.map

package/lib/typescript/theme/provider/PixelizeProvider.d.ts

@@ -1,81 +1,4 @@
-import type { ReactNode } from 'react';
-import { space, radii, fontSizes, fontWeights, lineHeights, letterSpacings, borderWidths, breakpoints, zIndices } from '../tokens';
-import type { ColorScheme, ElevationLevel, PaletteProps, RoleColors, ThemeName } from '../tokens';
-import type { ElevationStyle, FontStyleForWeight, FontWeightValue } from '../platform';
-import type { ColorModeStorageAdapter, ThemeMode } from './colorModeStorage';
-/**
- * The fully resolved theme for one (brand, resolvedMode): role colours resolved to plain strings,
- * the unitless numeric scale, and the platform-rendered pieces a token cannot hold (RN shadow props,
- * a font-style resolver). This is what `useTheme()` returns; component modules read it, never the
- * raw palette directly.
- */
-export type Theme = {
-    brand: ThemeName;
-    /** The resolved mode this theme was built for — never `'system'`. */
-    mode: ColorScheme;
-    /** Semantic role colours as resolved values. The `useThemeColors()` escape hatch returns this. */
-    colors: RoleColors;
-    /** The raw ramps, for the rare consumer that needs a specific rung the roles don't name. */
-    palette: PaletteProps;
-    space: typeof space;
-    radii: typeof radii;
-    fontSizes: typeof fontSizes;
-    fontWeights: typeof fontWeights;
-    lineHeights: typeof lineHeights;
-    letterSpacings: typeof letterSpacings;
-    borderWidths: typeof borderWidths;
-    breakpoints: typeof breakpoints;
-    zIndices: typeof zIndices;
-    /** Elevation levels already rendered to RN shadow props. Mode-independent — shared across themes. */
-    elevation: Record<ElevationLevel, ElevationStyle>;
-    /** A weight → RN text style, bound to whether the app has registered Inter. */
-    fontStyleForWeight: (weight: FontWeightValue) => FontStyleForWeight;
-};
-export type ThemeModeValue = {
-    /** The user's selection: `'light' | 'dark' | 'system'`. */
-    mode: ThemeMode;
-    /** What `system` currently resolves to, tracking the OS live. */
-    resolvedMode: ColorScheme;
-    /** Persists the choice and switches the theme. */
-    setMode: (mode: ThemeMode) => void;
-    /** The active brand. */
-    brand: ThemeName;
-    /** Persists the choice and switches the theme — mirrors `setMode`. */
-    setBrand: (brand: ThemeName) => void;
-};
-export type PixelizeProviderProps = {
-    children: ReactNode;
-    /**
-     * Initial brand. A persisted user choice wins over this. Defaults to `zinc` (the shadcn look).
-     * Read once on mount, like `mode` below — change it afterward via `setBrand` from
-     * `useThemeMode()`, not by re-passing a different prop value.
-     */
-    brand?: ThemeName;
-    /** Initial mode. A persisted user choice wins over this. Defaults to `system`. */
-    mode?: ThemeMode;
-    /** Persistence adapter. Absent → in-memory (choice lost on restart) + a dev warning. */
-    storage?: ColorModeStorageAdapter;
-    storageKey?: string;
-    /** Storage key for the brand choice — separate from `storageKey` (mode) so a plain-string
-     * adapter never has to encode two values into one slot. */
-    brandStorageKey?: string;
-    /**
-     * Whether the app has registered the Inter faces (`useFonts({...})`). Defaults to `false`: without
-     * this the library must use the always-safe system font, since an unregistered face degrades
-     * inconsistently across platforms. Pass `interLoaded={fontsLoaded}` once loading resolves.
-     */
-    interLoaded?: boolean;
-};
-/**
- * Two contexts, on purpose. `ThemeContext` holds the heavy resolved `Theme`; `ThemeModeContext` holds
- * the small mode-control triple. Both provider values are memoised on their true inputs, so:
- *  - a mode flip recomputes the theme exactly ONCE and re-renders each consumer once, and
- *  - an OS colour change while the mode is pinned (`resolvedMode` unchanged) keeps BOTH values
- *    reference-stable, so it re-renders nobody.
- * Splitting also means a `useThemeMode()` reader isn't invalidated by unrelated theme-object churn
- * and vice versa.
- */
-export declare const ThemeContext: import("react").Context<Theme | undefined>;
-export declare const ThemeModeContext: import("react").Context<ThemeModeValue | undefined>;
-export declare function PixelizeProvider({ children, brand: brandProp, mode, storage: storageProp, storageKey, brandStorageKey, interLoaded, }: PixelizeProviderProps): import("react").JSX.Element;
+import type { PixelizeProviderProps } from './types';
+export type { Theme, ThemeModeValue, PixelizeProviderProps } from './types';
+export declare function PixelizeProvider({ children, brand: brandProp, mode, storage: storageProp, storageKey, brandStorageKey, interLoaded, palette: paletteProp, }: PixelizeProviderProps): import("react").JSX.Element;
 //# sourceMappingURL=PixelizeProvider.d.ts.map

package/lib/typescript/theme/provider/ThemeContext.d.ts

@@ -0,0 +1,4 @@
+import type { Theme, ThemeModeValue } from './types';
+export declare const ThemeContext: import("react").Context<Theme | undefined>;
+export declare const ThemeModeContext: import("react").Context<ThemeModeValue | undefined>;
+//# sourceMappingURL=ThemeContext.d.ts.map