haze-ui 1.34.0 → 1.35.0

package/dist/sitemap.xml

@@ -3,12 +3,15 @@
   <url><loc>https://wmzy.github.io/haze-ui/</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/getting-started</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/recipes</loc></url>
+  <url><loc>https://wmzy.github.io/haze-ui/recipes/ai-elements</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/blocks</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/guides/dark-mode</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/guides/density</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/guides/a11y</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/guides/a11y-contracts</loc></url>
+  <url><loc>https://wmzy.github.io/haze-ui/guides/a11y-statement</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/guides/migration</loc></url>
+  <url><loc>https://wmzy.github.io/haze-ui/guides/deprecation-policy</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/guides/streaming-a11y</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/guides/motion</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/guides/figma-tokens</loc></url>
@@ -28,6 +31,7 @@
   <url><loc>https://wmzy.github.io/haze-ui/components/tooltip</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/popconfirm</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/popover</loc></url>
+  <url><loc>https://wmzy.github.io/haze-ui/components/notification-center</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/card</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/radio</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/textarea</loc></url>
@@ -68,6 +72,7 @@
   <url><loc>https://wmzy.github.io/haze-ui/components/chat-container</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/chat-input</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/streaming-text</loc></url>
+  <url><loc>https://wmzy.github.io/haze-ui/components/task-list</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/markdown-renderer</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/tool-call-card</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/thinking-indicator</loc></url>
@@ -140,6 +145,7 @@
   <url><loc>https://wmzy.github.io/haze-ui/components/schedule</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/sources</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/file-preview</loc></url>
+  <url><loc>https://wmzy.github.io/haze-ui/components/follow-up-suggestions</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/inline-completion</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/float-button</loc></url>
   <url><loc>https://wmzy.github.io/haze-ui/components/masonry</loc></url>

package/dist/tokens/index.js

@@ -5,4 +5,5 @@ import { spacing as f } from "./spacing.js";
 import { compact as p } from "./density.js";
 import { typography as m } from "./typography.js";
 import { motion as h, motionPresets as g } from "./motion.js";
-export { l as PRIMITIVES, u as SEMANTIC_COLOR_TOKENS, e as autoTheme, p as compact, d as createBrandTheme, t as darkTheme, r as deltaE, i as formatOklch, n as lightTheme, h as motion, g as motionPresets, a as oklchToHex, o as parseHex, s as parseOklch, f as spacing, m as typography, c as wcagContrast };
+import { remScale as _ } from "./zoom.js";
+export { l as PRIMITIVES, u as SEMANTIC_COLOR_TOKENS, e as autoTheme, p as compact, d as createBrandTheme, t as darkTheme, r as deltaE, i as formatOklch, n as lightTheme, h as motion, g as motionPresets, a as oklchToHex, o as parseHex, s as parseOklch, _ as remScale, f as spacing, m as typography, c as wcagContrast };

package/dist/tokens/zoom.js

@@ -0,0 +1,6 @@
+
+/* empty css               */
+//#region src/lib/tokens/zoom.ts
+var e = "haze-zoom__remScale";
+//#endregion
+export { e as remScale };

package/dist/types/components/Anchor/Anchor.d.ts

@@ -5,6 +5,8 @@ export type AnchorItem = {
     id: string;
     /** Link content. */
     label: ReactNode;
+    /** Nested second-level items, rendered as an indented sub-list. */
+    children?: AnchorItem[];
 };
 type AnchorProps = {
     /** Anchor sections, in document order. */
@@ -19,7 +21,9 @@ type AnchorProps = {
     bounds?: number;
     /** Scroll container; defaults to `window`. */
     getContainer?: () => HTMLElement | Window;
+    /** Renders a sliding indicator line along the active item (transform transition; no transition under prefers-reduced-motion). Default `false`. */
+    indicator?: boolean;
     className?: string;
 } & Omit<ComponentPropsWithoutRef<'nav'>, 'className' | 'onClick' | 'children'>;
-export default function Anchor({ items, activeId: activeIdControl, onClick, offsetTop, bounds, getContainer, className, ...rest }: AnchorProps): import("react").JSX.Element;
+export default function Anchor({ items, activeId: activeIdControl, onClick, indicator, offsetTop, bounds, getContainer, className, ...rest }: AnchorProps): import("react").JSX.Element;
 export type { AnchorProps };

package/dist/types/components/BackToTop/BackToTop.d.ts

@@ -1,7 +1,25 @@
-type BackToTopProps = {
+import type { ComponentPropsWithRef, ElementType, MouseEvent } from 'react';
+type BackToTopOwnProps = {
+    /** Scroll offset that reveals the button, px. Defaults to 300. */
     threshold?: number;
-    children?: React.ReactNode;
-    className?: string;
+    /**
+     * Element-agnostic click: whatever element `as` rendered, the
+     * consumer's handler fires first — the scroll-to-top wiring rides
+     * after it.
+     */
+    onClick?: (event: MouseEvent<HTMLElement>) => void;
 };
-export default function BackToTop({ threshold, children, className }: BackToTopProps): import("react").JSX.Element;
-export type { BackToTopProps };
+/**
+ * Polymorphic like Button's `as`: the fixed-corner skin, the scroll
+ * watching and the scroll-to-top click wiring always land on the
+ * rendered element — `as='a' href='#top'` keeps link semantics (⌘/
+ * middle-click, crawlers) while a click still scrolls. `type='button'`
+ * is gated to the native-button shape.
+ */
+type BackToTopProps<T extends ElementType = 'button'> = BackToTopOwnProps & {
+    /** Render element — 'button' (default), 'a', or any component that
+     * forwards props and ref to a DOM element. */
+    as?: T;
+} & Omit<ComponentPropsWithRef<T>, keyof BackToTopOwnProps | 'as' | 'type'>;
+export default function BackToTop<T extends ElementType = 'button'>({ threshold, as, className, children, onClick, ...rest }: BackToTopProps<T>): import("react").JSX.Element;
+export type { BackToTopOwnProps, BackToTopProps };

package/dist/types/components/Combobox/Combobox.d.ts

@@ -54,6 +54,22 @@ type ComboboxProps<T extends string | number = string> = {
      * selected chip.
      */
     multiple?: boolean;
+    /**
+     * Multiple mode only: cap the selectable count. Once the selection
+     * reaches `maxCount`, options that are not selected are disabled —
+     * dimmed, `aria-disabled`, clicks and Enter rejected — until
+     * something is deselected (selected options stay removable, and the
+     * creatable row is suppressed at the cap). Works the same
+     * controlled and uncontrolled; single mode ignores it.
+     */
+    maxCount?: number;
+    /**
+     * Multiple mode only: cap the rendered chips; the rest collapse into
+     * a `+N` badge whose `title` tooltip lists the overflow labels.
+     * Selection semantics are unchanged — the badge is presentational
+     * (removal stays through the panel, a chip's ×, or Backspace).
+     */
+    maxTagCount?: number;
     /**
      * Value callback for both modes — `T` in single mode, `T[]` when
      * `multiple` is set — fired after the value updates.
@@ -138,5 +154,5 @@ type ComboboxProps<T extends string | number = string> = {
      */
     ref?: Ref<HTMLInputElement>;
 };
-export default function Combobox<T extends string | number = string>({ value: valueControl, open: openControl, options, children, multiple, onValuesChange, creatable, onCreate, onSearch, loading, empty, highlightMatches, maxHeight, placeholder, virtualThreshold, virtualized: virtualizedProp, className, classNames, ref, }: ComboboxProps<T>): import("react").JSX.Element;
+export default function Combobox<T extends string | number = string>({ value: valueControl, open: openControl, options, children, multiple, maxCount, maxTagCount, onValuesChange, creatable, onCreate, onSearch, loading, empty, highlightMatches, maxHeight, placeholder, virtualThreshold, virtualized: virtualizedProp, className, classNames, ref, }: ComboboxProps<T>): import("react").JSX.Element;
 export type { ComboboxClassNames, ComboboxProps, ComboboxVirtualizedConfig, ComboboxOptionData };

package/dist/types/components/ConfigProvider/ConfigContext.d.ts

@@ -3,6 +3,7 @@ import type { SelectClassNames } from '../Select/Select.js';
 import type { ComboboxClassNames } from '../Combobox/Combobox.js';
 import type { TagGroupClassNames } from '../TagGroup/TagGroup.js';
 import type { MenuClassNames } from '../Menu/MenuContext.js';
+import type { NotificationCenterClassNames } from '../NotificationCenter/NotificationCenter.js';
 import type { ToastPlacement } from '../Toast/ToastContainer.js';
 import type { CalendarPickerMode } from '../Calendar/Calendar.js';
 import type { TimePickerFormat } from '../TimePicker/time.js';
@@ -112,6 +113,11 @@ type ComponentDefaultsSections = {
     Menu: {
         classNames?: MenuClassNames;
     };
+    /** `NotificationCenter` slot classes — merged under an explicit
+     *  `classNames` prop. */
+    NotificationCenter: {
+        classNames?: NotificationCenterClassNames;
+    };
     /** `Pagination` prop defaults. */
     Pagination: {
         /** Default `size` when the prop is omitted (built-in `'md'`). */

package/dist/types/components/CopyButton/CopyButton.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import type { ElementType, MouseEvent, ReactNode } from 'react';
 import type { ButtonProps } from '../Button/index.js';
 /** Semantic slot classes for CopyButton (AntD v6 `classNames` shape;
  * keys follow the data-slot names). */
@@ -23,15 +23,27 @@ type CopyButtonOwnProps = {
     copiedLabel?: string;
     /** Slot classes (see {@link CopyButtonClassNames}). */
     classNames?: CopyButtonClassNames;
+    /**
+     * Element-agnostic click: whatever element `as` rendered, the
+     * consumer's handler fires first — the copy wiring rides after it.
+     */
+    onClick?: (event: MouseEvent<HTMLElement>) => void;
 };
-type CopyButtonProps = CopyButtonOwnProps & {
+type CopyButtonProps<T extends ElementType = 'button'> = CopyButtonOwnProps & {
     /**
      * Icon or label. Defaults to the copy/check glyph pair; a function
      * receives the copied state so text labels can switch their own
      * wording (`(copied) => copied ? 'Copied!' : 'Copy'`).
      */
     children?: ReactNode | ((copied: boolean) => ReactNode);
-} & Omit<ButtonProps, keyof CopyButtonOwnProps | 'children'>;
+    /**
+     * Render element, delegated to the underlying `Button`'s polymorphism:
+     * `as='a'` renders a real anchor wearing the copy skin (`href` and the
+     * rest of the anchor surface type-check), any component works as long
+     * as it forwards props and ref to a DOM element.
+     */
+    as?: T;
+} & Omit<ButtonProps<T>, keyof CopyButtonOwnProps | 'children' | 'as'>;
 /**
  * A `Button` that copies text to the clipboard on click and flips into
  * a copied state for `copiedTimeout` ms (default 2000): the glyph
@@ -52,5 +64,5 @@ type CopyButtonProps = CopyButtonOwnProps & {
  * `aria-label` passed through the rest props overrides the swapped
  * `copyLabel`/`copiedLabel` naming (statically, for both states).
  */
-export default function CopyButton({ value, getValue, copiedTimeout, copyLabel, copiedLabel, variant, square, size, classNames, className, children, onClick, ...rest }: CopyButtonProps): import("react").JSX.Element;
+export default function CopyButton<T extends ElementType = 'button'>({ value, getValue, copiedTimeout, copyLabel, copiedLabel, variant, square, size, classNames, className, as, children, onClick, ...rest }: CopyButtonProps<T>): import("react").JSX.Element;
 export type { CopyButtonClassNames, CopyButtonProps };

package/dist/types/components/DataTable/DataTable.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/components/FloatButton/FloatButton.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import type { ComponentPropsWithRef, ComponentPropsWithoutRef, ElementType, MouseEvent, ReactNode } from 'react';
 /**
  * A floating action button pinned to the inline-end / block-end screen
  * corner — the "primary action" affordance material design popularized.
@@ -25,7 +25,7 @@ import type { ComponentPropsWithoutRef, ReactNode } from 'react';
  * An icon-only FloatButton has no accessible name — pass `aria-label`
  * (it spreads through like any native attribute) or a `description`.
  */
-type FloatButtonProps = {
+type FloatButtonOwnProps = {
     /** Icon slot; defaults to a plus glyph. Purely decorative (hidden
      * from AT) — the accessible name comes from `description` or
      * `aria-label`. */
@@ -38,6 +38,26 @@ type FloatButtonProps = {
     variant?: 'solid' | 'outline' | 'ghost';
     /** Render an anchor navigating to this URL instead of a button. */
     href?: string;
-} & Omit<ComponentPropsWithoutRef<'button'>, 'type'> & Omit<ComponentPropsWithoutRef<'a'>, 'children' | 'type'>;
-export default function FloatButton({ icon, description, shape, variant, href, className, onClick, ...rest }: FloatButtonProps): import("react").JSX.Element;
-export type { FloatButtonProps };
+    /**
+     * Element-agnostic click: whatever element `as` rendered, the
+     * consumer's handler fires first — the group's close-menu wiring
+     * rides after it.
+     */
+    onClick?: (event: MouseEvent<HTMLElement>) => void;
+};
+/**
+ * Polymorphic like Button's `as`: the FAB skin, the group wiring and
+ * the fixed anchor always land on the rendered element. `as` wins over
+ * the href duality's element choice (`as='a'` plus `href`, or a router
+ * Link component); without `as`, `href` alone still renders an anchor —
+ * the long-standing shape. `type='button'` is gated to the
+ * native-button shape, so anchors never carry it.
+ */
+type FloatButtonProps<T extends ElementType = 'button'> = FloatButtonOwnProps & {
+    /** Render element — overrides the href duality's button/anchor
+     * choice; any component that forwards props and ref to a DOM element
+     * works (a router Link is the canonical case). */
+    as?: T;
+} & Omit<ComponentPropsWithRef<T>, keyof FloatButtonOwnProps | 'as' | 'type'> & Omit<ComponentPropsWithoutRef<'a'>, keyof FloatButtonOwnProps | 'children' | 'type' | 'onClick' | 'className'>;
+export default function FloatButton<T extends ElementType = 'button'>({ icon, description, shape, variant, href, as, className, onClick, ...rest }: FloatButtonProps<T>): import("react").JSX.Element;
+export type { FloatButtonOwnProps, FloatButtonProps };

package/dist/types/components/FollowUpSuggestions/FollowUpSuggestions.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+/**
+ * AI chat follow-up suggestions ("猜你想问"): a horizontally wrapping
+ * row of clickable prompt chips shown after an answer. Chips wear
+ * Button's outline sm skin — Chip is display-only (a span), so Button
+ * supplies the native button semantics keyboard users need. Stateless:
+ * the caller owns the selection flow via `onSelect`.
+ */
+type FollowUpSuggestionsProps = {
+    /** Candidate prompts; one chip per entry, rendered in order. */
+    suggestions: string[];
+    /** Fired with the clicked chip's text. */
+    onSelect?: (value: string) => void;
+    /** Disables every chip (pointer and keyboard). */
+    disabled?: boolean;
+    /**
+     * Swaps the chips for skeleton placeholders — one per suggestion, or
+     * three when the list is still empty — so the row keeps its layout
+     * while the suggestions stream in.
+     */
+    loading?: boolean;
+    className?: string;
+    /** Forwarded to the root list div. */
+    ref?: Ref<HTMLDivElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'onSelect'>;
+export default function FollowUpSuggestions({ suggestions, onSelect, disabled, loading, className, ref, ...rest }: FollowUpSuggestionsProps): import("react").JSX.Element;
+export type { FollowUpSuggestionsProps };

package/dist/types/components/FollowUpSuggestions/index.d.ts

@@ -0,0 +1,2 @@
+export { default as FollowUpSuggestions } from './FollowUpSuggestions.js';
+export type { FollowUpSuggestionsProps } from './FollowUpSuggestions.js';

package/dist/types/components/LocaleProvider/locale.d.ts

@@ -189,6 +189,15 @@ declare const defaultStrings: {
     modelPicker: {
         label: string;
     };
+    notificationCenter: {
+        triggerLabel: string;
+        triggerLabelUnread: string;
+        panelTitle: string;
+        markAllRead: string;
+        clearAll: string;
+        empty: string;
+        unreadLabel: string;
+    };
     numberInput: {
         decrease: string;
         increase: string;

package/dist/types/components/NavigationBar/NavLink.d.ts

@@ -1,42 +1,34 @@
-import type { ComponentPropsWithoutRef, MouseEvent, ReactNode } from 'react';
+import type { ComponentPropsWithRef, ElementType, MouseEvent } from 'react';
 /**
- * Extends the native `<a>` attributes. Everything not listed below is spread
- * onto the rendered anchor, so callers (and routers composing NavLink via
- * their `as` prop) can inject `target`, `rel`, `aria-*`, and friends.
+ * Extends the rendered element's native attributes (anchor by default):
+ * everything not listed below is spread onto it, so callers can inject
+ * `target`, `rel`, `aria-*`, and friends.
  */
-type NavLinkProps = {
+type NavLinkOwnProps = {
     href?: string;
     /**
      * Explicit active state. Falls back to `aria-current="page"` when omitted,
      * letting routers drive highlighting through the standard aria attribute.
      */
     active?: boolean;
-    children: ReactNode;
     /**
-     * Native click handler: receives the underlying mouse event. Whether to
-     * call `event.preventDefault()` is up to the caller (an SPA router Link
-     * does so itself), except for placeholder hrefs where NavLink keeps
-     * button semantics (see the onClick handler below).
+     * Element-agnostic click: whatever element `as` rendered, the
+     * consumer's handler sees the event first — the placeholder-href
+     * `preventDefault` rides after it.
      */
-    onClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
-    className?: string;
-} & Omit<ComponentPropsWithoutRef<'a'>, 'href' | 'children' | 'onClick' | 'className'>;
-declare const _default: import("react").ForwardRefExoticComponent<{
-    href?: string;
-    /**
-     * Explicit active state. Falls back to `aria-current="page"` when omitted,
-     * letting routers drive highlighting through the standard aria attribute.
-     */
-    active?: boolean;
-    children: ReactNode;
-    /**
-     * Native click handler: receives the underlying mouse event. Whether to
-     * call `event.preventDefault()` is up to the caller (an SPA router Link
-     * does so itself), except for placeholder hrefs where NavLink keeps
-     * button semantics (see the onClick handler below).
-     */
-    onClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
-    className?: string;
-} & Omit<Omit<import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref">, "children" | "className" | "onClick" | "href"> & import("react").RefAttributes<HTMLAnchorElement>>;
-export default _default;
-export type { NavLinkProps };
+    onClick?: (event: MouseEvent<HTMLElement>) => void;
+};
+/**
+ * Polymorphic like Button's `as` (the anchor default mirrors NavLink's
+ * native root): the link skin, the `aria-current` wiring and the
+ * placeholder-href click handling always land on the rendered element —
+ * `as` with a router Link keeps NavLink's active styling while the
+ * router owns navigation.
+ */
+type NavLinkProps<T extends ElementType = 'a'> = NavLinkOwnProps & {
+    /** Render element — 'a' (default) or any component that forwards
+     * props and ref to a DOM element (a router Link). */
+    as?: T;
+} & Omit<ComponentPropsWithRef<T>, keyof NavLinkOwnProps | 'as'>;
+export default function NavLink<T extends ElementType = 'a'>({ href, active, as, className, 'aria-current': ariaCurrent, onClick, children, ...rest }: NavLinkProps<T>): import("react").JSX.Element;
+export type { NavLinkOwnProps, NavLinkProps };

package/dist/types/components/NotificationCenter/NotificationCenter.d.ts

@@ -0,0 +1,111 @@
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+/**
+ * Persistent notification center: a bell trigger with an unread-count
+ * badge opening a floating panel that lists notifications — the durable
+ * counterpart to Toast's transient stack (AntD `notification` /
+ * Mantine `notifications` shape, declarative data instead of an
+ * imperative `open()` API: the `items` prop is the source of truth and
+ * `onMarkAllRead` / `onClearAll` hand the mutations back to the app).
+ *
+ * Panel positioning, light-dismiss and Escape ride the shared floating
+ * engine (`utils/floating.tsx`); keyboard navigation reuses the Menu
+ * system (`utils/menuKeyboard`) — arrows / Home / End / typeahead walk
+ * the rows and the footer actions as one roving list, Escape / Tab
+ * close and return focus to the trigger. No z-index is declared here:
+ * every tier the panel can render on already resolves through the
+ * `tokens/z-index.ts` ladder inside the floating path classes.
+ */
+/** Semantic status of a notification — tints the kind icon. */
+type NotificationCenterSeverity = 'info' | 'success' | 'warning' | 'danger';
+/** Origin of a notification (the AI-workbench differentiation): picks
+ *  the leading glyph through the shared `Icon` wrapper. */
+type NotificationCenterKind = 'task' | 'agent' | 'system';
+/** One notification entry of the data-driven `items` prop. */
+type NotificationCenterItem = {
+    /** Stable identity (React key). */
+    key: string;
+    /** Primary line. */
+    title: ReactNode;
+    /** Secondary line under the title. */
+    description?: ReactNode;
+    /** Muted trailing line/label (already formatted — "2m ago"). */
+    timestamp?: ReactNode;
+    /** Status tint of the kind icon (built-in `'info'`). */
+    severity?: NotificationCenterSeverity;
+    /** Leading glyph (built-in `'system'`). */
+    kind?: NotificationCenterKind;
+    /** Read state — unread entries carry the dot accent and feed the
+     *  trigger's badge count (built-in unread, like a fresh feed). */
+    read?: boolean;
+};
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape), mirroring the
+ * data-slot names: consumer classes append at the end of each part's
+ * class list. A ConfigProvider `NotificationCenter.classNames` section
+ * merges under the prop, per key.
+ */
+type NotificationCenterClassNames = {
+    /** The wrapper `<span>` (`data-slot='notification-center'`). */
+    root?: string;
+    /** The bell `<button>` (`data-slot='trigger'`). */
+    trigger?: string;
+    /** The count badge wrapper (`data-slot='badge'`). */
+    badge?: string;
+    /** The floating panel (`data-slot='content'`). */
+    panel?: string;
+    /** The panel heading row (`data-slot='header'`). */
+    header?: string;
+    /** The heading itself (`data-slot='title'`). */
+    title?: string;
+    /** The list (`data-slot='list'`). */
+    list?: string;
+    /** Every notification row (`data-slot='notification-item'`). */
+    item?: string;
+    /** The kind/severity icon wrap (`data-slot='item-icon'`). */
+    itemIcon?: string;
+    /** A row's title/description column (`data-slot='item-body'`). */
+    itemBody?: string;
+    /** A row title (`data-slot='item-title'`). */
+    itemTitle?: string;
+    /** A row description (`data-slot='item-description'`). */
+    itemDescription?: string;
+    /** A row timestamp (`data-slot='item-timestamp'`). */
+    itemTimestamp?: string;
+    /** The unread dot (`data-slot='unread-dot'`). */
+    unreadDot?: string;
+    /** The footer action row (`data-slot='actions'`). */
+    actions?: string;
+    /** The mark-all-read button (`data-slot='mark-all-read'`). */
+    markAllRead?: string;
+    /** The clear-all button (`data-slot='clear-all'`). */
+    clearAll?: string;
+    /** The empty state (`data-slot='empty'`). */
+    empty?: string;
+};
+type NotificationCenterProps = {
+    /** The notification feed — declarative source of truth. */
+    items?: NotificationCenterItem[];
+    /** Panel visibility — controlled or uncontrolled, default closed. */
+    open?: ControlOrValue<boolean>;
+    /**
+     * Badge count ceiling: higher unread counts render as `{max}+`
+     * (built-in `99`; `0` keeps the badge rendered with a bare count).
+     */
+    maxBadgeCount?: number;
+    /** Fires when the footer's mark-all-read is activated. */
+    onMarkAllRead?: () => void;
+    /** Fires when the footer's clear-all is activated. */
+    onClearAll?: () => void;
+    /**
+     * Slot classes (see {@link NotificationCenterClassNames}); merged
+     * over any ConfigProvider `NotificationCenter.classNames` section,
+     * per key.
+     */
+    classNames?: NotificationCenterClassNames;
+    className?: string;
+    /** Forwarded to the root wrapper `<span>`. */
+    ref?: Ref<HTMLSpanElement>;
+} & Omit<ComponentPropsWithoutRef<'span'>, 'className' | 'children'>;
+export default function NotificationCenter({ items, open: openControl, maxBadgeCount, onMarkAllRead, onClearAll, classNames, className, ref, ...rest }: NotificationCenterProps): import("react").JSX.Element;
+export type { NotificationCenterClassNames, NotificationCenterItem, NotificationCenterKind, NotificationCenterProps, NotificationCenterSeverity, };

package/dist/types/components/NotificationCenter/index.d.ts

@@ -0,0 +1,2 @@
+export { default as NotificationCenter } from './NotificationCenter.js';
+export type { NotificationCenterClassNames, NotificationCenterItem, NotificationCenterKind, NotificationCenterProps, NotificationCenterSeverity, } from './NotificationCenter.js';

package/dist/types/components/Select/Select.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/components/Tabs/Tab.d.ts

@@ -1,7 +1,7 @@
-import type { KeyboardEvent as ReactKeyboardEvent, MouseEvent as ReactMouseEvent, ReactNode } from 'react';
+import type { ComponentPropsWithRef, ElementType, KeyboardEvent as ReactKeyboardEvent, MouseEvent, MouseEvent as ReactMouseEvent, ReactNode } from 'react';
 /** Document-tab status flavors — each maps to a dot color (see `TabStatusDot`). */
 type TabStatus = 'dirty' | 'error' | 'syncing';
-type TabProps = {
+type TabOwnProps = {
     value: string;
     /**
      * Inline-start icon slot, decorative (`aria-hidden`) — pair it with a
@@ -31,6 +31,12 @@ type TabProps = {
      * tab is disabled stays the consumer's story to tell.
      */
     disabled?: boolean;
+    /**
+     * Element-agnostic click: whatever element the plain (non-closable)
+     * tab rendered — `button` by default, any `as` element otherwise —
+     * the consumer's handler fires first, selection wiring after it.
+     */
+    onClick?: (event: MouseEvent<HTMLElement>) => void;
     /**
      * Renders the × close affordance. Purely notifying: activating it
      * calls `onClose` and nothing else — removing the tab from the
@@ -55,6 +61,22 @@ type TabProps = {
     className?: string;
     children: ReactNode;
 };
+/**
+ * Polymorphic like Button's `as`: the tab skin and the tablist wiring
+ * (`role='tab'`, `aria-selected`, the roving `tabIndex`, selection on
+ * click) always land on the rendered element — `as='a'` renders a
+ * link-shaped tab (tabs-as-routes) that keeps the strip's roving
+ * keyboard model. `type='button'` and the `disabled` attribute are
+ * gated to the native-button shape (anchors report through
+ * `aria-disabled`). Closable tabs keep their `div[role='tab']`
+ * promotion regardless — the nested × constraint dictates that shape.
+ */
+type TabProps<T extends ElementType = 'button'> = TabOwnProps & {
+    /** Render element for the plain (non-closable) tab — 'button'
+     * (default), 'a', or any component that forwards props and ref to a
+     * DOM element (a router Link). */
+    as?: T;
+} & Omit<ComponentPropsWithRef<T>, keyof TabOwnProps | 'as' | 'type'>;
 /**
  * The decorative status dot shared by `Tab` and the TabList overflow
  * menu. Color-only by design (`aria-hidden`) — the SR-visible meaning
@@ -63,5 +85,5 @@ type TabProps = {
 export declare function TabStatusDot({ status }: {
     status: TabStatus;
 }): import("react").JSX.Element;
-export default function Tab({ value, icon, status, statusLabel, closable, closeLabel, onClose, disabled, className, children, }: TabProps): import("react").JSX.Element;
-export type { TabProps, TabStatus };
+export default function Tab<T extends ElementType = 'button'>({ value, icon, status, statusLabel, closable, closeLabel, onClose, disabled, as, className, children, onClick, ...rest }: TabProps<T>): import("react").JSX.Element;
+export type { TabOwnProps, TabProps, TabStatus };

package/dist/types/components/TaskList/TaskList.d.ts

@@ -0,0 +1,50 @@
+import type { ComponentPropsWithoutRef, Key, ReactNode } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type TaskListProps = {
+    /** `TaskList.Item` elements. */
+    children?: ReactNode;
+    /**
+     * Data-driven mode: renders one `TaskList.Item` per entry — the
+     * compound path underneath, so every entry keeps the full checkbox
+     * machinery (`useControl` wiring, completion styling). Mutually
+     * exclusive with compound `children`; when both are given, `items`
+     * wins and a dev-time console.error explains the conflict (the Tabs
+     * `items` precedent).
+     */
+    items?: TaskData[];
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'ul'>, 'children'>;
+type TaskListItemProps = {
+    /** Completion state — controlled or uncontrolled, default `false`. */
+    checked?: ControlOrValue<boolean>;
+    /** Fires on every check transition, whatever drove it. */
+    onCheckedChange?: (checked: boolean) => void;
+    /** Task summary; strikes through and dims once `checked`. */
+    title: ReactNode;
+    /** Secondary line under the title (agent output, links, timing). */
+    description?: ReactNode;
+    /** Replaces the default checkbox toggle — e.g. a `Spinner` for a
+     * running task. The row stops being interactive: no checkbox
+     * renders, the title keeps reflecting `checked`. */
+    indicator?: ReactNode;
+    /** Trailing affordances (copy/retry buttons), kept outside the
+     * toggle label so activating them never toggles the task. */
+    actions?: ReactNode;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'li'>, 'children' | 'title'>;
+type TaskData = {
+    /** React key of the rendered item (the Tabs `value` precedent). */
+    key: Key;
+    checked?: ControlOrValue<boolean>;
+    onCheckedChange?: (checked: boolean) => void;
+    title: ReactNode;
+    description?: ReactNode;
+    indicator?: ReactNode;
+    actions?: ReactNode;
+    className?: string;
+};
+declare function TaskListItem({ checked: checkedControl, onCheckedChange, title, description, indicator, actions, className, ...rest }: TaskListItemProps): import("react").JSX.Element;
+declare function TaskList({ items, children, className, ...rest }: TaskListProps): import("react").JSX.Element;
+export default TaskList;
+export { TaskListItem };
+export type { TaskListProps, TaskListItemProps, TaskData };

package/dist/types/components/TaskList/index.d.ts

@@ -0,0 +1,2 @@
+export { default as TaskList, TaskListItem } from './TaskList.js';
+export type { TaskListProps, TaskListItemProps, TaskData } from './TaskList.js';