pixelize-native-library 1.0.6 → 1.2.0

package/lib/typescript/modules/limit-reached-modal/LimitReachedModal.variants.d.ts

@@ -0,0 +1,46 @@
+/**
+ * LimitReachedModal's pure resolvers. Mirrors `AlertDialog.variants.ts`'s split: this module owns
+ * no colour resolver for the panel or the actions — those are `Modal`'s and `Button`'s own,
+ * applied unchanged (see `Modal.test.ts` / `Button.test.ts`). What IS this module's own contract:
+ * the six-`kind` × admin/member copy table (ported verbatim from web's `limitReachedCopy.ts` so
+ * both platforms read identically), the usage-line formatter, and the icon badge's own colour
+ * pairing (`status.warning.text` on `status.warning.subtle` — the same proven pairing Badge/Banner
+ * use for their own `subtle` variant, not a fresh, unmeasured one).
+ *
+ * Free of React and of any `Modal`/`Button` RENDER import — only `RoleColors`'s TYPE is pulled in
+ * — so this stays a pure resolver file, exactly like `AlertDialog.variants.ts`.
+ */
+import type { RoleColors, Theme } from "../../theme/hooks";
+export type LimitKind = "record" | "automation" | "custom_modules" | "user" | "projects" | "tickets";
+export interface LimitReachedCopy {
+    readonly title: string;
+    readonly message: string;
+}
+/** `canManageBilling` selects the admin (upgrade-able) or member ("ask your admin") message. */
+export declare function resolveLimitReachedCopy(kind: LimitKind, canManageBilling: boolean): LimitReachedCopy;
+/** `null` when either value is missing — the caller renders no usage line at all in that case. */
+export declare function formatLimitUsage(kind: LimitKind, used?: number | null, limit?: number | null): string | null;
+export interface LimitReachedModalColors {
+    /** Icon badge fill. */
+    readonly iconBadge: string;
+    /** Icon glyph on `iconBadge` — the same `status.warning.text` on `status.warning.subtle`
+     *  pairing Badge/Banner's own `subtle` variant already proves ≥ 4.5:1 for every brand × mode. */
+    readonly icon: string;
+    /** Message body, read on the panel's `bg.surface`. */
+    readonly message: string;
+    /** Usage line — secondary, muted. */
+    readonly usage: string;
+}
+/**
+ * Maps LimitReachedModal onto the theme's role colours. The severity is fixed (`warning` — a plan
+ * limit is a soft stop, not a destructive action), so there is no `tone` prop to widen; every
+ * colour this component can show is one of these role lookups.
+ */
+export declare function resolveLimitReachedModalColors(colors: RoleColors): LimitReachedModalColors;
+export declare const LIMIT_REACHED_MODAL_ICON_SIZE = 20;
+export declare const LIMIT_REACHED_MODAL_ICON_BADGE_SIZE = 40;
+/** The icon's circular badge — structural only, colour applied inline over this. */
+export declare const limitReachedModalIconBadgeStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/** The two-action row beneath the usage line — same shape as `alertDialogActionsStructure`. */
+export declare const limitReachedModalActionsStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+//# sourceMappingURL=LimitReachedModal.variants.d.ts.map

package/lib/typescript/modules/limit-reached-modal/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Public surface of `pixelize-native-library/limit-reached-modal`. Value exports and type exports
+ * are split for `verbatimModuleSyntax`. The copy table, usage formatter, and colour/structure
+ * resolvers stay internal — a consumer configures a LimitReachedModal through its props, never by
+ * importing its internals.
+ */
+export { LimitReachedModal } from "./LimitReachedModal";
+export type { LimitReachedModalProps } from "./LimitReachedModal";
+export type { LimitKind } from "./LimitReachedModal.variants";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/list-item/ListItem.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ListItem — a row primitive. It is rendered AS a list cell at scale, so it carries no mount
+ * animation and no loop: the only motion is `usePressMotion`, which starts on touch and runs on the
+ * native driver. The pressable root is an animated `Pressable` rather than an `Animated.View`
+ * wrapper so a 5000-row list pays for no extra node.
+ */
+import type { ReactNode } from "react";
+import type { LayoutStyle } from "../../core/style";
+export interface ListItemProps {
+    leading?: ReactNode;
+    title: string;
+    subtitle?: string;
+    trailing?: ReactNode;
+    unread?: boolean;
+    onPress?: () => void;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+export declare const ListItem: import("react").NamedExoticComponent<ListItemProps>;
+//# sourceMappingURL=ListItem.d.ts.map

package/lib/typescript/modules/list-item/ListItem.variants.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Pure resolvers for ListItem — no React, so the WCAG tests import this directly (mocking only
+ * `react-native`'s `StyleSheet`, as every sibling module's tests do).
+ */
+import type { RoleColors, Theme } from "../../theme/hooks";
+export declare const LIST_ITEM_DOT_SIZE = 8;
+export declare const LIST_ITEM_MIN_HEIGHT = 44;
+export interface ListItemColors {
+    /** `undefined` for a read row — the row stays transparent over whatever list background hosts it. */
+    readonly background: string | undefined;
+    readonly pressed: string;
+    readonly title: string;
+    readonly subtitle: string;
+    readonly dot: string;
+}
+export declare function resolveListItemColors(colors: RoleColors, unread: boolean): ListItemColors;
+export interface ListItemAccessibilityInput {
+    readonly title: string;
+    readonly subtitle: string | undefined;
+    readonly unread: boolean;
+}
+export interface ListItemAccessibilityProps {
+    readonly accessibilityLabel: string;
+}
+export declare function resolveListItemAccessibility(input: ListItemAccessibilityInput): ListItemAccessibilityProps;
+export declare const listItemStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const listItemBodyStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const listItemDotStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+//# sourceMappingURL=ListItem.variants.d.ts.map

package/lib/typescript/modules/list-item/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Public surface of `pixelize-native-library/list-item`. Value exports and type exports are split
+ * for `verbatimModuleSyntax`. The resolvers stay internal — a consumer configures a ListItem
+ * through its props, never by importing its internals.
+ */
+export { ListItem } from "./ListItem";
+export type { ListItemProps } from "./ListItem";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/markdown/Markdown.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A markdown document is rendered whole, never virtualized: the heading outline is what a screen
+ * reader's rotor navigates, and windowing would expose only the ~10 blocks currently on screen
+ * (WCAG 2.4.1). It is also normally embedded in a caller's ScrollView, where a nested
+ * VirtualizedList is an error in its own right.
+ */
+import type { LayoutStyle } from "../../core/style";
+export interface MarkdownProps {
+    content: string;
+    onLinkPress?: (url: string) => void;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+export declare const Markdown: import("react").NamedExoticComponent<MarkdownProps>;
+//# sourceMappingURL=Markdown.d.ts.map

package/lib/typescript/modules/markdown/Markdown.variants.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Pure resolvers for Markdown — no React, so the WCAG tests import this directly (mocking only
+ * `react-native`'s `StyleSheet`, as every sibling module's tests do).
+ */
+import type { HeadingLevel } from "../../core/heading";
+import type { RoleColors, Theme } from "../../theme/hooks";
+export interface MarkdownColors {
+    readonly text: string;
+    readonly heading: string;
+    readonly codeBackground: string;
+    readonly code: string;
+    readonly link: string;
+    readonly quoteBorder: string;
+    readonly quoteText: string;
+    readonly listMarker: string;
+}
+export declare function resolveMarkdownColors(colors: RoleColors): MarkdownColors;
+export interface MarkdownHeadingSpec {
+    readonly fontSize: number;
+    readonly fontWeight: "semibold" | "bold";
+}
+/**
+ * SIZE only — `h4`–`h6` deliberately share `h3`'s size while keeping their own `aria-level`. The
+ * document's structure is what the heading level carries; three more type sizes below `lg` would
+ * be smaller than body text.
+ */
+export declare function resolveMarkdownHeading(theme: Theme, level: HeadingLevel): MarkdownHeadingSpec;
+export declare const markdownStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const markdownCodeBlockStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const markdownBlockquoteStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const markdownListStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const markdownListRowStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+//# sourceMappingURL=Markdown.variants.d.ts.map

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

@@ -0,0 +1,10 @@
+/**
+ * Public surface of `pixelize-native-library/markdown`. Value exports and type exports are split
+ * for `verbatimModuleSyntax`. The parser is exported for consumers that need the node tree
+ * (e.g. extracting plain text); the style resolvers stay internal.
+ */
+export { Markdown } from "./Markdown";
+export type { MarkdownProps } from "./Markdown";
+export { parseMarkdown } from "./parseMarkdown";
+export type { MarkdownBlockNode, MarkdownInlineNode } from "./parseMarkdown";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/markdown/parseMarkdown.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A small hand-rolled markdown parser — no dependencies, never throws. Supports the subset the
+ * renderer draws: h1–h6, bold, italic, inline code, fenced code blocks, unordered/ordered lists,
+ * links, blockquotes, paragraphs. Anything malformed degrades to literal text.
+ */
+import type { HeadingLevel } from "../../core/heading";
+export type MarkdownInlineNode = {
+    readonly type: "text";
+    readonly content: string;
+} | {
+    readonly type: "bold";
+    readonly content: string;
+} | {
+    readonly type: "italic";
+    readonly content: string;
+} | {
+    readonly type: "code";
+    readonly content: string;
+} | {
+    readonly type: "link";
+    readonly content: string;
+    readonly url: string;
+};
+export type MarkdownBlockNode = {
+    readonly type: "heading";
+    readonly level: HeadingLevel;
+    readonly children: readonly MarkdownInlineNode[];
+} | {
+    readonly type: "paragraph";
+    readonly children: readonly MarkdownInlineNode[];
+} | {
+    readonly type: "code-block";
+    readonly content: string;
+} | {
+    readonly type: "blockquote";
+    readonly children: readonly MarkdownInlineNode[];
+} | {
+    readonly type: "list";
+    readonly ordered: boolean;
+    readonly items: readonly (readonly MarkdownInlineNode[])[];
+};
+export declare function parseInline(text: string): MarkdownInlineNode[];
+export declare function parseMarkdown(content: string): MarkdownBlockNode[];
+//# sourceMappingURL=parseMarkdown.d.ts.map

package/lib/typescript/modules/menu/Menu.d.ts

@@ -1,26 +1,19 @@
 /**
- * Menu — a small anchored action list opened from a caller-supplied trigger. Unlike Select (whose
- * open/closed state is a `value`/`onValueChange` pair the caller owns), Menu is self-contained: a
- * transient action list manages its own visibility, closing itself after every dismissal path.
+ * Menu — a small anchored action list opened from a caller-supplied trigger.
  *
- * The trigger is composed via `React.cloneElement` — never `{...rest}` — injecting only `onPress`,
- * chained after any handler the trigger already defined (the same "merge, never clobber" technique
- * Tooltip uses for its child). The dropdown itself is React Native's OWN `Modal`, imported directly
- * from `"react-native"` on purpose: this module must never depend on the library's own `Modal`
- * COMPONENT — this library's own `Modal` (built in parallel elsewhere) is for persistent app
- * dialogs with a title/children contract, not a quick transient overlay — the same distinction
- * Select already draws for its own option list.
+ * The sheet is the menu itself: it carries `accessibilityRole="menu"` over the `menuitem` rows, and
+ * the `accessibilityViewIsModal` / `onAccessibilityEscape` pair `Modal.tsx` establishes — set on the
+ * sheet node itself so the web-portal path (which has no RN `<Modal>`) is modal to assistive tech too.
  *
- * The one deliberate exception is the web portal mechanism: `ModalPortalContext`/`renderWebPortal`
- * are a plain context + a stateless helper with no React-tree footprint of their own (not the
- * `Modal` component), so Menu reads the same ones `Modal.tsx` and `Select.tsx` read to stay
- * consistent once a consumer opts in via `ModalPortalProvider` — see `../modal/ModalPortalContext.ts`.
+ * Motion split, same as this library's own `Modal`: RN `<Modal>`'s native `animationType` owns the
+ * scrim fade (in AND out, with no JS timer, so a selection closes the menu on the same tick it
+ * always did), and the global motion system (`core/motion`) owns the sheet's own scale + lift on
+ * enter. The sheet is centered rather than anchored (see MODULE.md), so it scales from its centre.
  */
 import type { ReactElement } from "react";
 import type { GestureResponderEvent } from "react-native";
 import type { IconName } from "../../core/icon";
 import type { MenuItemTone } from "./Menu.variants";
-/** The subset of props Menu reads from / injects into its trigger child. */
 export interface MenuTriggerProps {
     onPress?: (event: GestureResponderEvent) => void;
 }
@@ -31,11 +24,8 @@ export interface MenuItem {
     readonly tone?: MenuItemTone;
 }
 export interface MenuProps {
-    /** A single element that accepts `onPress` (e.g. a `Button`). Opens the menu on press. */
     trigger: ReactElement<MenuTriggerProps>;
     items: MenuItem[];
-    /** Blocks the menu from opening. Does not itself restyle the trigger — pass `disabled` to the
-     *  trigger too if it should also look disabled (Menu never rewrites a prop it didn't ask for). */
     disabled?: boolean;
     testID?: string;
 }

package/lib/typescript/modules/menu/Menu.variants.d.ts

@@ -9,7 +9,7 @@
  * Free of React, `lucide`, and any `Modal`/`Pressable` import, so the WCAG + touch-target 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 MenuItemTone = "default" | "danger";
 /** Same touch-target floor as Button/Select (44dp — Apple HIG minimum, WCAG 2.5.5 AAA). */
 export declare const MIN_TOUCH_TARGET = 44;
@@ -26,6 +26,13 @@ export declare const MENU_ROW_ICON_SIZE = 18;
  * 3:1 non-text minimum for free.
  */
 export declare function resolveMenuItemColor(colors: RoleColors, tone: MenuItemTone): string;
+/**
+ * A row's background while pressed — `bg.sunken`, not `bg.hover`: same class of fix `Button`'s
+ * "neutral" tone and `RadioGroup`/`Accordion` document (the saturated `hover` mid-tone risks
+ * dropping a tinted label below 4.5:1; the pale `sunken` tint doesn't). One background for every
+ * tone: `default` and `danger` labels are both measured against it in `Menu.test.ts`.
+ */
+export declare function resolveMenuRowPressedBackground(colors: RoleColors): string;
 /**
  * Structural styles only — layout, padding, radius, border WIDTH. No colours (those are resolved
  * from `RoleColors` and applied inline), so this compiles once per theme identity via the themed

package/lib/typescript/modules/message-bubble/MessageBubble.d.ts

@@ -0,0 +1,25 @@
+/**
+ * MessageBubble — a single chat turn bubble. User variant uses accent fill; assistant uses surface
+ * card with border. Plain-text `content` only (rich assistant replies compose Markdown/RichText
+ * upstream).
+ *
+ * The accessible label names the sender ("You" / "Assistant") ahead of the content: alignment and
+ * fill colour are the only things that say who spoke, and neither reaches a screen reader.
+ *
+ * No mount animation, by rule 5 of `core/motion/MODULE.md`: bubbles are list cells, and `FlatList`
+ * unmounts and remounts them as they leave and re-enter its window — a "plays once per mount" enter
+ * therefore replays for every bubble scrolled back into view, which is exactly the per-row motion
+ * during scroll that rule forbids. A "new message arrived" reveal would have to be keyed off the
+ * message's own identity (an id/timestamp high-water mark the consumer owns), never off mounting.
+ */
+import type { LayoutStyle } from "../../core/style";
+import type { MessageBubbleVariant } from "./MessageBubble.variants";
+export interface MessageBubbleProps {
+    variant?: MessageBubbleVariant;
+    content: string;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+export declare const MessageBubble: import("react").NamedExoticComponent<MessageBubbleProps>;
+//# sourceMappingURL=MessageBubble.d.ts.map

package/lib/typescript/modules/message-bubble/MessageBubble.variants.d.ts

@@ -0,0 +1,31 @@
+import type { RoleColors, Theme } from "../../theme/hooks";
+export type MessageBubbleVariant = "user" | "assistant";
+export interface MessageBubbleColors {
+    readonly background: string;
+    readonly text: string;
+    readonly border?: string;
+}
+export declare function resolveMessageBubbleColors(colors: RoleColors, variant: MessageBubbleVariant): MessageBubbleColors;
+export declare const messageBubbleStructure: import("../../core/style").ThemedVariantResolver<Theme, {
+    variant: {
+        user: {
+            alignSelf: "flex-end";
+            borderBottomRightRadius: 4;
+        };
+        assistant: {
+            alignSelf: "flex-start";
+            borderBottomLeftRadius: 4;
+            borderWidth: 1;
+        };
+    };
+}, import("react-native").ViewStyle>;
+/**
+ * Who sent a turn is carried only by `alignSelf` and the bubble fill on screen, so the label has to
+ * name the sender for it to reach assistive tech at all (WCAG 1.3.1).
+ */
+export declare function resolveMessageBubbleAccessibility(content: string, variant: MessageBubbleVariant): {
+    readonly accessible: true;
+    readonly accessibilityRole: "text";
+    readonly accessibilityLabel: string;
+};
+//# sourceMappingURL=MessageBubble.variants.d.ts.map

package/lib/typescript/modules/message-bubble/index.d.ts

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

package/lib/typescript/modules/modal/Modal.d.ts

@@ -4,6 +4,12 @@
  * backdrop scrim dismisses it on press; the panel sits on `bg.surface` with `theme.radii.lg` and
  * `theme.elevation.lg`, capped to one of three closed widths (`size`).
  *
+ * Motion split: RN's own `animationType` owns the SURFACE fade (in AND out, natively, with no JS
+ * timer), and the global motion system (`core/motion`) owns the panel's own entrance lift. The exit
+ * is deliberately left to the native transition — a JS-timed exit would have to keep the `<Modal>`
+ * mounted past `visible`, widening the window in which iOS drops a sibling `<Modal>` presented while
+ * this one is dismissing.
+ *
  * Fully controlled: the caller owns `visible` and reacts to `onRequestClose`, which fires from the
  * backdrop press, the Android hardware back button, and — via `onAccessibilityEscape` on the panel
  * — iOS VoiceOver's two-finger-Z escape gesture. (RN's `<Modal>` only fires `onRequestClose` from a
@@ -17,6 +23,12 @@
  * `renderWebPortal` instead — see `ModalPortalContext.ts` for why. Every other case (native, or web
  * with no provider — the default `ModalPortalContext` value is `null`) renders through RN's own
  * `<Modal>`, byte-identical to before this mechanism existed.
+ *
+ * Physical-keyboard support is scoped to exactly that portal branch. `react-native-web`'s own
+ * `<Modal>` already ships Escape, a Tab trap and focus restore (`ModalContent`/`ModalFocusTrap`),
+ * so the RNModal path below must stay untouched — wiring the hooks there too would give the page
+ * two Escape listeners and two competing traps. The portal branch renders no `<RNModal>` at all,
+ * which is where all three silently went missing.
  */
 import type { ReactNode } from "react";
 import type { ModalSize } from "./Modal.variants";

package/lib/typescript/modules/modal/Modal.variants.d.ts

@@ -9,7 +9,7 @@
  * Free of React and of any `Modal`/`Pressable` 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 ModalSize = "sm" | "md" | "lg";
 export interface ModalSizeSpec {
     /** Panel max width in dp — a screen narrower than this still shrinks it via `width: "100%"`. */

package/lib/typescript/modules/more-items/MoreItems.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MoreItems — "+N more" overflow affordance opening a sheet of hidden items (avatars, tags, etc.).
+ */
+import type { LayoutStyle } from "../../core/style";
+import type { MoreItemsEntry } from "./MoreItems.variants";
+export interface MoreItemsProps {
+    items: readonly MoreItemsEntry[];
+    moreCount?: number;
+    triggerText?: string;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+export declare const MoreItems: import("react").NamedExoticComponent<MoreItemsProps>;
+//# sourceMappingURL=MoreItems.d.ts.map

package/lib/typescript/modules/more-items/MoreItems.variants.d.ts

@@ -0,0 +1,30 @@
+import type { RoleColors, Theme } from "../../theme/hooks";
+import type { BadgeTone } from "../badge/Badge.variants";
+export interface MoreItemsEntry {
+    readonly id: string;
+    readonly label: string;
+    readonly tone?: BadgeTone;
+}
+export declare function resolveMoreItemsCount(moreCount: number | undefined, itemsLength: number): number;
+/** Tone dot beside each overflow label. */
+export declare const MORE_ITEMS_DOT_SIZE = 8;
+/** The sheet never grows past this — the list inside it scrolls (and virtualizes). */
+export declare const MORE_ITEMS_SHEET_MAX_HEIGHT = 280;
+/**
+ * 44dp is Apple's HIG minimum and WCAG 2.5.5 (AAA); it comfortably exceeds 2.5.8's 24×24 (AA). The
+ * trigger reaches it with `minHeight` rather than `hitSlop`: it is a standalone node with no
+ * neighbouring target to overlap, and a slop-expanded rectangle would still leave a ~22dp visual
+ * control that misses under an unsteady finger.
+ */
+export declare const MIN_TOUCH_TARGET = 44;
+export declare const moreItemsTriggerStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/** The trigger's animated layer: press motion moves the content, never the outer layout box. */
+export declare const moreItemsTriggerContentStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/** Overflow-list row. Height is text-driven (font scaling), so the list gets no fixed itemHeight. */
+export declare const moreItemsRowStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const moreItemsDotStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const moreItemsOverlayStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const moreItemsSheetStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const moreItemsBadgeStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare function resolveMoreItemsDotColor(colors: RoleColors, tone?: BadgeTone): string;
+//# sourceMappingURL=MoreItems.variants.d.ts.map

package/lib/typescript/modules/more-items/index.d.ts

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

package/lib/typescript/modules/multi-select/MultiSelect.d.ts

@@ -1,21 +1,13 @@
 /**
- * MultiSelect — a trigger styled like Select/Input that opens a checkbox-style option list in React
- * Native's OWN `Modal`. Imported directly from `"react-native"` here on purpose, and built as a
- * standalone sibling of `Select` rather than on top of it: selection semantics differ enough
- * (multiple values, a running "N selected" summary, checkbox-row indicators instead of a single
- * check mark) that importing Select would force awkward prop overloading — and this module must not
- * depend on any sibling module, including the library's own Modal (built in parallel elsewhere).
- *
- * The one deliberate exception is the web portal mechanism: `ModalPortalContext`/`renderWebPortal`
- * are a plain context + a stateless helper with no React-tree footprint of their own (not the
- * `Modal` component), so MultiSelect reads the same ones `Modal.tsx`/`Select.tsx` read to stay
- * consistent once a consumer opts in via `ModalPortalProvider` — see `../modal/ModalPortalContext.ts`.
+ * MultiSelect — a trigger styled like Select/Input that opens a checkbox-style option list.
  */
+import type { ReactNode } from "react";
 import type { LayoutStyle } from "../../core/style";
 import type { MultiSelectSize } from "./MultiSelect.variants";
 export interface MultiSelectOption {
     readonly label: string;
     readonly value: string;
+    readonly leading?: ReactNode;
 }
 export interface MultiSelectProps {
     options: MultiSelectOption[];
@@ -25,7 +17,6 @@ export interface MultiSelectProps {
     label?: string;
     disabled?: boolean;
     size?: MultiSelectSize;
-    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
     containerStyle?: LayoutStyle;
     testID?: string;
 }

package/lib/typescript/modules/multi-select/MultiSelect.variants.d.ts

@@ -15,7 +15,8 @@
  * Free of React and of any `Modal`/`Pressable` 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 { AccessibilityRole } from "react-native";
+import type { RoleColors, Theme } from "../../theme/hooks";
 export type MultiSelectSize = "sm" | "md" | "lg";
 /** Same touch-target floor as Button/Select (44dp — Apple HIG minimum, WCAG 2.5.5 AAA). */
 export declare const MIN_TOUCH_TARGET = 44;
@@ -51,6 +52,13 @@ export declare const MULTI_SELECT_SIZES: {
 };
 /** Minimum height for an option row — a list item is still an interactive target (WCAG 2.5.8). */
 export declare const MULTI_SELECT_ROW_MIN_HEIGHT = 44;
+/**
+ * The option list's container role. RN 0.86's role unions have no `listbox` — both `Role` and
+ * `AccessibilityRole` jump `list` → `listitem` → `log` — so the widening lives on this ONE audited
+ * line instead of a cast at the call site. It is a type gap, not a runtime one: `react-native-web`
+ * emits the string as the DOM `role` verbatim, and native maps roles it doesn't know to nothing.
+ */
+export declare const MULTI_SELECT_LISTBOX_ROLE: AccessibilityRole;
 /** Row checkbox-style indicator box side, in dp. Fixed — independent of the trigger's own `size`,
  *  same reasoning as `Select`'s row "check" glyph. */
 export declare const MULTI_SELECT_ROW_INDICATOR_SIZE = 20;
@@ -94,6 +102,10 @@ export interface MultiSelectRowColors {
     /** Check glyph on `indicatorFill` — the derived on-colour (≥ 3:1 non-text; measured, never
      *  assumed), same role pairing `Checkbox` uses. */
     readonly indicatorIcon: string;
+    /** Row background while pressed — `bg.sunken`, not `bg.hover`: same class of fix `Button`'s
+     *  "neutral" tone and `RadioGroup`/`Accordion` document (the saturated `hover` mid-tone risks
+     *  dropping `text` below 4.5:1 on brand-tinted palettes; the pale `sunken` tint doesn't). */
+    readonly pressedRow: string;
 }
 export declare function resolveMultiSelectRowColors(colors: RoleColors): MultiSelectRowColors;
 export interface MultiSelectAccessibilityInput {
@@ -102,10 +114,10 @@ export interface MultiSelectAccessibilityInput {
 }
 export interface MultiSelectAccessibilityProps {
     readonly accessibilityRole: "button";
-    readonly accessibilityState: {
-        readonly disabled: boolean;
-        readonly expanded: boolean;
-    };
+    /** 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-disabled": boolean;
+    readonly "aria-expanded": boolean;
     /** The `Pressable disabled` prop — blocks opening the sheet while disabled. */
     readonly disabled: boolean;
 }
@@ -143,6 +155,13 @@ export declare const multiSelectSheetStructure: import("../../core/style").Theme
 export declare const multiSelectHeaderStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
 export declare const multiSelectCloseButtonStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
 export declare const multiSelectRowStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/**
+ * `MultiSelectOption.leading` is an arbitrary consumer node, so an unconstrained one could make a
+ * row taller than `MULTI_SELECT_ROW_MIN_HEIGHT` and silently falsify the list's `getItemLayout`
+ * offsets. This slot bounds it to the row's own indicator box instead, which is what keeps the
+ * uniform-height fast path true by construction (`core/MODULE.md`: `itemHeight` is uniform-only).
+ */
+export declare const multiSelectRowLeadingStructure: import("../../core/style").ThemedVariantResolver<object, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
 /** Structural indicator-box styles only — size, radius, border WIDTH. No colours: border/fill
  *  colour is checked-state-driven and applied inline over this, same split as `checkboxBoxStructure`. */
 export declare const multiSelectRowIndicatorStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;

package/lib/typescript/modules/number-input/NumberInput.d.ts

@@ -24,6 +24,12 @@ export interface NumberInputProps {
     disabled?: boolean;
     /** Rendered above the field. Also becomes `accessibilityLabel` unless one is passed explicitly. */
     label?: string;
+    /**
+     * The validity message. Shown below the field and folded into the accessible name when `status`
+     * is `"error"` — same prop name and rule as `Input`/`FormField`. Without it an error is a red
+     * border and nothing else, which no screen-reader or colour-blind user can perceive.
+     */
+    errorText?: string;
     /** Overrides the label→`accessibilityLabel` fallback. */
     accessibilityLabel?: string;
     /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */