@imfusion/web-ui 0.11.1-dev.5.g8a97f4f6 → 0.11.1-dev.52.g8c3c8d4b

package/dist/components/combobox/index.d.ts

@@ -0,0 +1,2 @@
+export * as Combobox from './combobox';
+export { comboboxMeta } from './combobox.meta';

package/dist/components/file-drop-zone/collect-files.d.ts

@@ -0,0 +1,56 @@
+export interface FileDropZoneItem {
+    file: File;
+    /** Folder-relative path with the root folder's name first (`"scans/s1.nii.gz"`), or the file name for a loose file. */
+    path: string;
+}
+export interface CollectResult {
+    accepted: FileDropZoneItem[];
+    rejected: FileDropZoneItem[];
+}
+interface CollectOptions {
+    accept?: string[];
+    directory: boolean;
+    multiple: boolean;
+}
+/** The part of a `FileSystemEntry` the walk reads. */
+export interface EntryLike {
+    readonly isFile: boolean;
+    readonly isDirectory: boolean;
+    readonly name: string;
+    readonly fullPath: string;
+}
+/** What the synchronous part of a `drop` handler can read; the drag data store is gone after the first `await`. */
+interface DropSource {
+    entry: EntryLike | null;
+    file: File | null;
+}
+/** The part of a `DataTransfer` that `snapshotDrop` reads. */
+interface DropData {
+    items: ArrayLike<{
+        kind: string;
+        webkitGetAsEntry: () => EntryLike | null;
+        getAsFile: () => File | null;
+    }>;
+    files: ArrayLike<File>;
+}
+export type DragState = "idle" | "accepting" | "rejecting";
+export declare function matchesAccept(file: File, accept?: string[]): boolean;
+/**
+ * A drag shows each item's MIME type but never its name, so only a type that is known to come from other extensions
+ * than the accepted ones is judged `"rejecting"`. A type missing from the table, an empty one, or an empty item list
+ * (Safari lists no items during a drag) stays `"accepting"`.
+ */
+export declare function classifyDrag(items: ArrayLike<{
+    kind: string;
+    type: string;
+}>, accept?: string[]): DragState;
+/** Reads every `webkitGetAsEntry()` and `getAsFile()` of a drop. Call it synchronously inside the `drop` handler. */
+export declare function snapshotDrop(dataTransfer: DropData): DropSource[];
+export declare function collectFromDrop(sources: DropSource[], options: CollectOptions): Promise<CollectResult>;
+/** Files from a picker. A folder pick carries `webkitRelativePath`, which includes the chosen folder's name. */
+export declare function collectFromFileList(files: File[], options: CollectOptions & {
+    fromFolder: boolean;
+}): CollectResult;
+/** Names the accepted types for copy: `[".png", ".jpg", ".jpeg", ".webp"]` becomes "PNG, JPEG or WebP". Empty without a list. */
+export declare function describeAccept(accept?: string[]): string;
+export {};

package/dist/components/file-drop-zone/file-drop-zone-context.d.ts

@@ -0,0 +1,15 @@
+export type FileDropZoneSize = "sm" | "md" | "lg";
+interface FileDropZoneContextValue {
+    size: FileDropZoneSize;
+    disabled: boolean;
+    directory: boolean;
+    /** Whether a `FileDropZone.File` is mounted. */
+    filled: boolean;
+    openPicker: (mode: "files" | "folder") => void;
+    setFilled: (filled: boolean) => void;
+    registerTitle: (id: string | null) => void;
+    registerDescription: (id: string | null) => void;
+}
+/** What `FileDropZone.Root` hands to its parts; a part outside a Root reads the inert defaults. */
+export declare const FileDropZoneContext: import('react').Context<FileDropZoneContextValue>;
+export {};

package/dist/components/file-drop-zone/file-drop-zone.d.ts

@@ -0,0 +1,185 @@
+import { VariantProps } from 'class-variance-authority';
+import { Button } from '../button';
+import { Icon, IconComponent } from '../icon';
+import { IconButton } from '../icon-button';
+import { DragState, FileDropZoneItem } from './collect-files';
+declare const root: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type RootProps = React.ComponentProps<"div"> & VariantProps<typeof root> & {
+    /** Accepted file types: extensions (`".nii.gz"`), MIME types (`"image/png"`) or wildcards (`"image/*"`). Any file when empty. */
+    accept?: string[];
+    /** Whether more than one file can be added at once. With `false`, only the first accepted file is kept. */
+    multiple?: boolean;
+    /** Whether folders can be dropped or picked. They are scanned recursively. Needs `multiple`. */
+    directory?: boolean;
+    /** Blocks dropping and picking; the Triggers follow. */
+    disabled?: boolean;
+    /** Marks the zone as holding a problem. The message belongs in `Field.Error` or a `Callout`. */
+    invalid?: boolean;
+    /** Called once per drop or pick with the files that match `accept` and those that do not. */
+    onFilesAdded?: (accepted: FileDropZoneItem[], rejected: FileDropZoneItem[]) => void;
+    /**
+     * Called when a drag over the zone starts, changes or ends. `"rejecting"` is reported only for a dragged type the
+     * browser exposes and `accept` cannot produce; names and counts are unknown until the drop.
+     */
+    onDragStateChange?: (state: DragState) => void;
+    /** Words for the screen reader status after each drop or pick. Return `""` to stay silent. */
+    formatStatus?: (accepted: number, rejected: number) => string;
+};
+/**
+ * FileDropZone.Root — a group that collects files and folders by drop or by its Triggers and reports them through
+ * `onFilesAdded`. The Triggers are the keyboard and screen reader path; dropping is an enhancement.
+ */
+export declare function Root({ accept, multiple, directory, size, disabled, invalid, onFilesAdded, onDragStateChange, formatStatus, children, className, "aria-labelledby": ariaLabelledBy, "aria-describedby": ariaDescribedBy, onDragEnter, onDragOver, onDragLeave, onDrop, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+/** FileDropZone.Title — names the group. */
+export declare function Title(props: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export declare namespace Title {
+    var displayName: string;
+}
+/** FileDropZone.Description — describes the group, such as the accepted file types. */
+export declare function Description(props: React.ComponentProps<"p">): import("react/jsx-runtime").JSX.Element;
+export declare namespace Description {
+    var displayName: string;
+}
+/** FileDropZone.Actions — the row of Triggers. */
+export declare function Actions(props: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export declare namespace Actions {
+    var displayName: string;
+}
+type FileProps = React.ComponentProps<"div"> & {
+    /** The single file the zone holds. Its name shows middle-truncated, with the last 12 characters kept, and its size in mono. */
+    file: globalThis.File;
+};
+/**
+ * FileDropZone.File — the file a single-file zone holds, in place of `Title` and `Description`. It names the group,
+ * describes it with the size, and sets `data-filled` on the Root while mounted. Long names truncate in the middle so the
+ * extension stays readable; the full name is the `title`.
+ */
+export declare function File({ file, className, ...props }: FileProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace File {
+    var displayName: string;
+}
+type IconButtonProps = React.ComponentProps<typeof IconButton>;
+type RemoveProps = Omit<IconButtonProps, "glyph" | "label"> & {
+    /** Accessible name of the button. Defaults to "Remove file". */
+    label?: string;
+    /** Defaults to `"ghost"` in an `sm` zone and `"outline"` otherwise. */
+    variant?: IconButtonProps["variant"];
+    /** Defaults to `"md"` in an `lg` zone and `"sm"` otherwise. */
+    size?: IconButtonProps["size"];
+    /** Defaults to the zone's `disabled`. */
+    disabled?: IconButtonProps["disabled"];
+};
+/** FileDropZone.Remove — an icon button that empties a filled zone. It carries no behavior of its own: `onClick` clears the consumer's state. */
+export declare function Remove({ label, variant, size, disabled, ...props }: RemoveProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Remove {
+    var displayName: string;
+}
+type GlyphProps = Omit<React.ComponentProps<typeof Icon>, "glyph"> & {
+    /** Icon component imported from `@imfusion/web-ui/icons`. Defaults to `UploadSquare`, or `Page` while a File is mounted. */
+    glyph?: IconComponent;
+};
+/** FileDropZone.Glyph — the large icon of the `lg` zone: the upload icon, or a page while a `FileDropZone.File` is mounted. It renders nothing in `sm` and `md`. */
+export declare function Glyph({ glyph, size, ...props }: GlyphProps): import("react/jsx-runtime").JSX.Element | null;
+export declare namespace Glyph {
+    var displayName: string;
+}
+type ButtonProps = React.ComponentProps<typeof Button>;
+type TriggerProps = ButtonProps & {
+    /** `"files"` opens the file picker, `"folder"` the folder picker. A folder Trigger needs `directory` on the Root. */
+    mode?: "files" | "folder";
+    /** Defaults to `"ghost"` in an `sm` zone and `"outline"` otherwise. */
+    variant?: ButtonProps["variant"];
+    /** Defaults to `"md"` in an `lg` zone and `"sm"` otherwise. */
+    size?: ButtonProps["size"];
+    /** Defaults to the zone's `disabled`. */
+    disabled?: ButtonProps["disabled"];
+};
+/** FileDropZone.Trigger — a Button that opens the picker. */
+export declare function Trigger({ mode, variant, size, disabled, onClick, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element | null;
+export declare namespace Trigger {
+    var displayName: string;
+}
+export interface FileDropZoneUploadItem {
+    /** Identifies the row in `onRemove`. */
+    id: string;
+    file: globalThis.File;
+    /** Shown instead of the file name, such as a folder-relative path. */
+    path?: string;
+    /** `"queued"` and `"error"` rows list the file with a Remove button; `"uploading"` and `"done"` rows show a progress bar. */
+    status: "queued" | "uploading" | "done" | "error";
+    /** From 0 to 100 while `"uploading"`; `null` while the amount is unknown. */
+    progress?: number | null;
+}
+interface UploadLabels {
+    chooseFiles: string;
+    chooseFolder: string;
+    /** Text of the upload button, from the number of queued items. */
+    upload: (queued: number) => string;
+    /** Text beside "Start over" once the upload has finished, from the number of items done and failed. */
+    uploaded: (done: number, failed: number) => string;
+    overall: string;
+    startOver: string;
+    uploading: string;
+    done: string;
+    failed: string;
+    waiting: string;
+    /** Accessible name of the file list. */
+    files: string;
+    dropToAdd: string;
+    cantAdd: string;
+    releaseToAdd: (multiple: boolean) => string;
+    /** Hint while a drag the zone cannot accept is over it, from the named accepted types ("" without `accept`). */
+    addTypes: (types: string) => string;
+    remove: (name: string) => string;
+    retry: string;
+    /** Accessible name of a row's Retry button. */
+    retryName: (name: string) => string;
+    /** The note under the zone. `types` is set only when every skipped file failed the `accept` check. */
+    skipped: (info: {
+        count: number;
+        paths: string[];
+        types: string;
+    }) => string;
+    /** Screen reader announcement when the upload starts. */
+    uploadingStatus: (count: number) => string;
+}
+type UploadProps = Omit<RootProps, "children" | "directory" | "title" | "onReset"> & {
+    /** The files to list, in order. The app owns this list and each item's `status` and `progress`. */
+    items: FileDropZoneUploadItem[];
+    /** Called with the `id` of the row whose Remove button was pressed. */
+    onRemove: (id: string) => void;
+    /** Called when the upload button is pressed. The app starts the upload and moves the queued items to `"uploading"`. */
+    onUpload: () => void;
+    /**
+     * Called with the `id` of a failed row whose Retry button was pressed. The app sends the file again and moves the row
+     * back to `"uploading"`. Failed rows show Retry only when this is set.
+     */
+    onRetry?: (id: string) => void;
+    /** Called by "Start over" once every item is done or failed. The button shows only when this is set. */
+    onReset?: () => void;
+    /** Heading of the card around the zone and the list. */
+    heading?: React.ReactNode;
+    /** Title of the zone. Defaults to "Drop files or a folder", or "Drop a file" without `multiple`. */
+    title?: React.ReactNode;
+    /** Text under the zone title. Defaults to the accepted types, such as "PNG, JPEG or WebP", and a note that folders are scanned. */
+    description?: React.ReactNode;
+    /** Whether the zone takes whole folders, with a "Choose folder" button. Needs `multiple`. */
+    folders?: boolean;
+    /** Replaces any of the English texts: the button texts, the drag copy, the row states, the skipped note, the finished text. */
+    labels?: Partial<UploadLabels>;
+};
+/**
+ * FileDropZone.Upload — the upload sequence in one piece: a zone, the list of collected files to check and remove, a
+ * `Progress` per row and overall once the upload runs, and the upload button. It is controlled and uploads nothing: the app
+ * keeps `items`, performs the upload, and reports each item's `status` and `progress`. Other props go to the zone.
+ */
+export declare function Upload({ items, onRemove, onUpload, onRetry, onReset, heading, title, description, folders, labels, size, multiple, accept, disabled, onFilesAdded, onDragStateChange, ...zoneProps }: UploadProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Upload {
+    var displayName: string;
+}
+export {};

package/dist/components/file-drop-zone/file-drop-zone.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const fileDropZoneMeta: ComponentMeta;

package/dist/components/file-drop-zone/format-bytes.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Formats a size such as "3.1 MB", in the unit that suits `scale` (the size itself by default). `digits` sets the decimals;
+ * by default one below ten units and none above. Bytes have none.
+ */
+export declare function formatBytes(bytes: number, scale?: number, digits?: number): string;

package/dist/components/file-drop-zone/index.d.ts

@@ -0,0 +1,4 @@
+export * as FileDropZone from './file-drop-zone';
+export type { FileDropZoneItem } from './collect-files';
+export type { FileDropZoneUploadItem } from './file-drop-zone';
+export { fileDropZoneMeta } from './file-drop-zone.meta';

package/dist/components/logo/logo.d.ts

@@ -1,7 +1,7 @@
 import { ReactNode } from 'react';
 import { VariantProps } from 'class-variance-authority';
 declare const logo: (props?: ({
-    size?: "sm" | "md" | "lg" | "hero" | "xl" | "xs" | "fit" | null | undefined;
+    size?: "sm" | "md" | "lg" | "hero" | "xs" | "xl" | "fit" | null | undefined;
     variant?: "inherit" | "main" | "support" | "minor" | "brand" | "oncolor" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 type Props = Omit<React.ComponentProps<"span">, "children"> & VariantProps<typeof logo> & {

package/dist/components/popover/popover.d.ts

@@ -19,7 +19,7 @@ export declare function Root<Payload = unknown>(props: RootProps<Payload>): impo
 export declare namespace Root {
     var displayName: string;
 }
-/** Popover.Trigger — button that opens the popover. */
+/** Popover.Trigger — button that opens the popover. With `render`, the rendered element keeps its own styles, such as a `Button`. */
 export declare function Trigger({ variant, inline, ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger> & VariantProps<typeof popoverTrigger>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Trigger {
     var displayName: string;
@@ -35,7 +35,7 @@ export declare namespace Backdrop {
     var displayName: string;
 }
 /** Popover.Positioner — positions the popup relative to the trigger via floating-point layout. */
-export declare function Positioner(props: React.ComponentProps<typeof PopoverPrimitive.Positioner>): import("react/jsx-runtime").JSX.Element;
+export declare function Positioner({ sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Positioner>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Positioner {
     var displayName: string;
 }

package/dist/components/progress/index.d.ts

@@ -0,0 +1,2 @@
+export * as Progress from './progress';
+export { progressMeta } from './progress.meta';

package/dist/components/progress/progress.d.ts

@@ -0,0 +1,40 @@
+import { Progress as ProgressPrimitive } from '@base-ui/react/progress';
+import { VariantProps } from 'class-variance-authority';
+declare const progressRoot: (props?: ({
+    size?: "sm" | "md" | "lg" | "xs" | null | undefined;
+    layout?: "inline" | "stacked" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+/**
+ * Progress.Root — completion of a running task, such as an upload or export.
+ *
+ * `value={null}` is indeterminate. Without a visible `Progress.Label`, name the bar with `aria-label`. Base UI hides
+ * `Progress.Value` from assistive tech, so custom Value text needs a matching `aria-valuetext`.
+ *
+ * @doc https://base-ui.com/react/components/progress
+ * @llm https://base-ui.com/react/components/progress.md
+ */
+export declare function Root({ size, layout, ...props }: React.ComponentProps<typeof ProgressPrimitive.Root> & VariantProps<typeof progressRoot>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+/** Progress.Label — accessible label for the progress bar. */
+export declare function Label(props: React.ComponentProps<typeof ProgressPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Label {
+    var displayName: string;
+}
+/** Progress.Value — formatted readout of the current value. Renders nothing while indeterminate. */
+export declare function Value(props: React.ComponentProps<typeof ProgressPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Value {
+    var displayName: string;
+}
+/** Progress.Track — the full range. */
+export declare function Track(props: React.ComponentProps<typeof ProgressPrimitive.Track>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Track {
+    var displayName: string;
+}
+/** Progress.Indicator — filled portion of the track up to the value. */
+export declare function Indicator(props: React.ComponentProps<typeof ProgressPrimitive.Indicator>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Indicator {
+    var displayName: string;
+}
+export {};

package/dist/components/progress/progress.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const progressMeta: ComponentMeta;

package/dist/components/select/select.cva.d.ts

@@ -0,0 +1,7 @@
+/** Popup, list, and item styles, shared with primitives that open the same list (Combobox, Autocomplete). */
+export declare const selectPopup: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const selectList: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const selectItem: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const selectItemIndicator: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const selectItemText: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const selectItemDescription: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;

package/dist/components/select/select.d.ts

@@ -2,7 +2,7 @@ import { Select as SelectPrimitive } from '@base-ui/react/select';
 import { VariantProps } from 'class-variance-authority';
 type UpstreamItem = React.ComponentProps<typeof SelectPrimitive.Item>;
 declare const selectRoot: (props?: ({
-    width?: "auto" | "full" | "wide" | null | undefined;
+    width?: "auto" | "wide" | "full" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 interface RootProps<Value = unknown, Multiple extends boolean | undefined = false> extends React.ComponentProps<typeof SelectPrimitive.Root<Value, Multiple>> {
     /** Trigger width: `auto` keeps the compact minimum; `wide` raises it; `full` fills the parent. @default "auto" */

package/dist/components/tab-nav/index.d.ts

@@ -0,0 +1,2 @@
+export * as TabNav from './tab-nav';
+export { tabNavMeta } from './tab-nav.meta';

package/dist/components/tab-nav/tab-nav.d.ts

@@ -0,0 +1,26 @@
+import { useRender } from '@base-ui/react/use-render';
+interface RootProps extends React.ComponentProps<"nav"> {
+    /** Names the navigation for screen readers, such as "Project". */
+    "aria-label": string;
+}
+/**
+ * TabNav.Root — a `<nav>` of links that draws the hairline under its items. Give it an `aria-label` that names the
+ * navigation, such as "Project".
+ * Not based on any upstream component.
+ */
+export declare function Root(props: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+type ItemProps = useRender.ComponentProps<"a"> & {
+    /** Marks the item as the page the user is on: sets `aria-current="page"` and `data-current`, and draws the bar. */
+    current?: boolean;
+};
+/**
+ * TabNav.Item — a link in the row. Renders an `<a>`; pass a router link as `render` to navigate without a page load.
+ */
+export declare function Item({ current, render, ...props }: ItemProps): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare namespace Item {
+    var displayName: string;
+}
+export {};

package/dist/components/tab-nav/tab-nav.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const tabNavMeta: ComponentMeta;

package/dist/components/table/table.d.ts

@@ -46,6 +46,14 @@ export declare function RowLink({ render, ...props }: useRender.ComponentProps<"
 export declare namespace RowLink {
     var displayName: string;
 }
+/**
+ * Table.RowButton — a `<button>` that stands for its whole row, such as one that opens a drawer. Use it when the row acts
+ * instead of navigating; a link that goes to a page is a `Table.RowLink`.
+ */
+export declare function RowButton({ render, type, ...props }: useRender.ComponentProps<"button">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare namespace RowButton {
+    var displayName: string;
+}
 /**
  * Table.HeaderButton — inline action button for header cells. Generic by
  * design: sorting toggles, filter toggles, column menus all render through it

package/dist/components/tabs/tabs-underline.cva.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The underline look shared by `Tabs` (appearance `"underline"`) and `TabNav`, which renders it on links. Keeping it here
+ * avoids cross-component imports between the two.
+ */
+export declare const tabsUnderlineRule: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const tabsUnderlineItem: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;

package/dist/components/tabs/tabs.d.ts

@@ -2,18 +2,27 @@ import { Tabs as TabsPrimitive } from '@base-ui/react/tabs';
 import { VariantProps } from 'class-variance-authority';
 declare const tabsList: (props?: ({
     fill?: boolean | null | undefined;
+    appearance?: "underline" | "boxed" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type TabsAppearance = "boxed" | "underline";
+interface RootProps extends React.ComponentProps<typeof TabsPrimitive.Root> {
+    /**
+     * `"boxed"` outlines the active tab in a box that fuses into a framed panel. `"underline"` marks it with a bar under
+     * its label on a hairline rule, with an unframed panel. Underline is horizontal only: a vertical Tabs stays boxed.
+     */
+    appearance?: TabsAppearance;
+}
 /**
  * Tabs.Root — container that manages the active tab value and orientation context.
  *
  * @see https://base-ui.com/react/components/tabs
  * @llm https://base-ui.com/react/components/tabs.md
  */
-export declare function Root(props: React.ComponentProps<typeof TabsPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export declare function Root({ appearance, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace Root {
     var displayName: string;
 }
-interface ListProps extends React.ComponentProps<typeof TabsPrimitive.List>, VariantProps<typeof tabsList> {
+interface ListProps extends React.ComponentProps<typeof TabsPrimitive.List>, Pick<VariantProps<typeof tabsList>, "fill"> {
     /**
      * Give every tab an equal share of the list's length (equal width when
      * horizontal). When vertical, this only takes effect if the list is stretched
@@ -32,7 +41,7 @@ export declare namespace Tab {
     var displayName: string;
 }
 /**
- * Tabs.Indicator — the bordered box marking the active tab, positioned via
+ * Tabs.Indicator — the bordered box (boxed) or bar (underline) marking the active tab, positioned via
  * the `--active-tab-*` CSS custom properties Base UI writes onto it. Render
  * once per Tabs.List, after the Tabs.Tab list.
  */
@@ -43,7 +52,7 @@ export declare namespace Indicator {
 /**
  * Tabs.PanelViewport — the shared frame Tabs.Panel elements render inside.
  * No Base UI equivalent exists; it's surfaced as a named part since its
- * hairline border is what Tabs.Indicator visually fuses into.
+ * hairline border is what the boxed Tabs.Indicator visually fuses into. The underline appearance draws no frame.
  */
 export declare function PanelViewport(props: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
 export declare namespace PanelViewport {

package/dist/components/textarea/index.d.ts

@@ -0,0 +1,2 @@
+export { Textarea } from './textarea';
+export { textareaMeta } from './textarea.meta';

package/dist/components/textarea/textarea.d.ts

@@ -0,0 +1,32 @@
+import { Input as InputPrimitive } from '@base-ui/react/input';
+import { VariantProps } from 'class-variance-authority';
+declare const textarea: (props?: ({
+    variant?: "outline" | "ghost" | "filled" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    resize?: "none" | "both" | "horizontal" | "vertical" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type UpstreamInput = React.ComponentProps<typeof InputPrimitive>;
+interface Props extends Omit<React.ComponentProps<"textarea">, "className" | "style" | "value" | "defaultValue">, Pick<UpstreamInput, "value" | "defaultValue" | "onValueChange" | "render">, VariantProps<typeof textarea> {
+    /** Number of visible text lines. */
+    rows?: number;
+    /**
+     * Which directions the user can drag to resize. `horizontal` and `both` size the textarea from `cols` and shrink-wrap
+     * the root, so the width follows the drag; `none` hides the resize corner.
+     */
+    resize?: "vertical" | "horizontal" | "both" | "none";
+    /** Class of the root wrapper that lays the field out. */
+    className?: string;
+    /** Style of the root wrapper that lays the field out. */
+    style?: React.CSSProperties;
+}
+/**
+ * Multi-line text input. Also called a text area; use Input for a single line.
+ * Wraps Base UI Input rendered as a textarea for controlled/uncontrolled state, form integration,
+ * and Field context awareness (valid/invalid/dirty/touched/filled/focused). `className` and `style`
+ * go to the root wrapper; every other prop goes to the textarea.
+ *
+ * @see https://base-ui.com/react/components/input
+ * @llm https://base-ui.com/react/components/input.md
+ */
+export declare function Textarea({ variant, size, rows, resize, render, className, style, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/textarea/textarea.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const textareaMeta: ComponentMeta;

package/dist/components/toast/toast.d.ts

@@ -2,10 +2,10 @@ import { Toast as ToastPrimitive } from '@base-ui/react/toast';
 import { VariantProps } from 'class-variance-authority';
 declare const toastViewport: (props?: ({
     position?: "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right" | null | undefined;
-    width?: "default" | "content" | "compact" | "wide" | null | undefined;
+    width?: "default" | "content" | "wide" | "compact" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 declare const toastRoot: (props?: ({
-    variant?: "warning" | "info" | "neutral" | "success" | "error" | null | undefined;
+    variant?: "warning" | "info" | "error" | "neutral" | "success" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 /**
  * Toast.useToastManager — reads the queue and the add/close/update/promise

package/dist/components/typo/typo.d.ts

@@ -9,6 +9,10 @@ type WeightProps = {
     /** Font weight. Omit to keep the member's default; `medium` firms up short body text on cards. */
     weight?: "regular" | "medium" | "strong";
 };
+type MarkerProps = {
+    /** Colour of the dash. Omit to follow the text colour. */
+    markerVariant?: TypoProps["variant"];
+};
 type HeadingProps = useRender.ComponentProps<"h1"> & TypoProps;
 type LongHeadingProps = HeadingProps & {
     /** Whether lines after the first use a translucent text color. */
@@ -99,7 +103,7 @@ export declare namespace OrderedList {
     var displayName: string;
 }
 /** Typo.UnorderedList — bulleted list. */
-export declare function UnorderedList({ variant, weight, render, ...props }: useRender.ComponentProps<"ul"> & TypoProps & WeightProps): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function UnorderedList({ variant, markerVariant, weight, render, ...props }: useRender.ComponentProps<"ul"> & TypoProps & WeightProps & MarkerProps): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
 export declare namespace UnorderedList {
     var displayName: string;
 }

package/dist/docgen/component-sources.d.ts

@@ -4,4 +4,8 @@ export type ComponentSource = {
     componentFile: string;
     metaFile: string;
 };
+/**
+ * A component folder is public when the package index exports it; an unexported folder is internal.
+ * Integrations ship through their own entry points and are always public.
+ */
 export declare function publicComponentSources(srcDir: string): ComponentSource[];