cortena-ui 0.1.0 → 1.0.0

package/dist/index.d.ts

@@ -1,8 +1,39 @@
 "use client";
 import { ClassValue } from "clsx";
+import * as React$1 from "react";
+import { ReactNode } from "react";
+import { Area, AreaChart, Bar, BarChart, CartesianGrid, Cell, ComposedChart, Funnel, FunnelChart, LabelList, Legend as RechartsLegend, LegendPayload, LegendProps, Line, LineChart, Pie, PieChart, PolarAngleAxis, PolarGrid, PolarRadiusAxis, Radar, RadarChart, ReferenceLine, ResponsiveContainer, Scatter, ScatterChart, Tooltip as RechartsTooltip, TooltipContentProps as TooltipContentProps$1, TooltipProps, XAxis, YAxis } from "recharts";
 import { Button as Button$1 } from "@base-ui/react/button";
 import { VariantProps } from "class-variance-authority";
-import * as React from "react";
+import { Menu } from "@base-ui/react/menu";
+import { Select as Select$1 } from "@base-ui/react/select";
+import { Cell as Cell$2, Column, ColumnDef, ColumnHelper, ReactTable, Row, RowData, TableState } from "@tanstack/react-table";
+import { Checkbox as Checkbox$1 } from "@base-ui/react/checkbox";
+import { Accordion as Accordion$1 } from "@base-ui/react/accordion";
+import { Avatar as Avatar$1 } from "@base-ui/react/avatar";
+import { DateRange, DayButtonProps, DayPickerProps } from "react-day-picker";
+import { Combobox as Combobox$1 } from "@base-ui/react/combobox";
+import { Command as Command$1 } from "cmdk";
+import { Dialog as Dialog$1 } from "@base-ui/react/dialog";
+import { Popover as Popover$1 } from "@base-ui/react/popover";
+import { Accept, DropzoneState, FileRejection } from "react-dropzone";
+import { Field as Field$1 } from "@base-ui/react/field";
+import { Fieldset as Fieldset$1 } from "@base-ui/react/fieldset";
+import { ControllerProps, FieldError as FieldError$1, FieldPath, FieldValues, SubmitHandler, UseFormReturn, useForm } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { Components, Options } from "react-markdown";
+import { Options as Options$1 } from "rehype-sanitize";
+import { Progress as Progress$1 } from "@base-ui/react/progress";
+import { Radio } from "@base-ui/react/radio";
+import { RadioGroup as RadioGroup$1 } from "@base-ui/react/radio-group";
+import { ScrollArea as ScrollArea$1 } from "@base-ui/react/scroll-area";
+import { Separator as Separator$1 } from "@base-ui/react/separator";
+import { DraggableAttributes, UniqueIdentifier } from "@dnd-kit/core";
+import { arrayMove } from "@dnd-kit/sortable";
+import { Switch as Switch$1 } from "@base-ui/react/switch";
+import { Tabs as Tabs$1 } from "@base-ui/react/tabs";
+import { Toast as Toast$1 } from "@base-ui/react/toast";
+import { Tooltip as Tooltip$2 } from "@base-ui/react/tooltip";
 //#region src/lib/cn.d.ts
 /**
  * Merge class names the shadcn way: clsx for conditionals, tailwind-merge so a
@@ -10,6 +41,865 @@ import * as React from "react";
  */
 export declare function cn(...inputs: ClassValue[]): string;
 //#endregion
+//#region src/components/chart/types.d.ts
+/**
+ * Chart types and the data shape each one expects.
+ *
+ * Engine per type (see cortena-docs/cortenaUI&Design/03-charting.md):
+ *
+ * | type                                                     | engine                    |
+ * | -------------------------------------------------------- | ------------------------- |
+ * | bar, line, area, pie, donut, scatter, radar, funnel      | Recharts (static import)  |
+ * | heatmap, calendar, treemap, sunburst                     | Nivo (lazy, per package)  |
+ *
+ * Data shapes (the webchat renderer's legacy shapes are all accepted):
+ *
+ * - **bar**, **radar**: `ChartRow[]` — one object per category with a string
+ *   category key (`indexBy`, inferred as the first string field) and one
+ *   numeric field per series (`keys`, inferred as every numeric field).
+ *   `[{ month: "Jan", revenue: 12, cost: 8 }, …]`. The series shape below is
+ *   also accepted and pivoted.
+ * - **line**, **area**: `ChartSeries[]` — `[{ id: "revenue", data: [{ x, y }] }]`
+ *   (the Nivo line shape the webchat emits). `ChartRow[]` is also accepted.
+ * - **pie**, **donut**, **funnel**: `ChartSlice[]` — `[{ id, label?, value }]`.
+ * - **scatter** (alias `scatterplot`): `ChartSeries[]` — one series per group.
+ * - **heatmap**: `ChartSeries[]` — Nivo heatmap shape, `[{ id: row, data: [{ x: column, y: value }] }]`.
+ * - **calendar**: `ChartDay[]` — `[{ day: "2026-01-31", value }]`; `from`/`to`
+ *   default to the data's range.
+ * - **treemap**, **sunburst**: `ChartTree` — Nivo tree, `{ id, children?: [...], value? }`
+ *   (`name` is accepted in place of `id`).
+ */
+type ChartType = "bar" | "line" | "area" | "pie" | "donut" | "scatter" | "scatterplot" | "radar" | "funnel" | "heatmap" | "calendar" | "treemap" | "sunburst";
+/** The engine that draws a given type. */
+type ChartEngine = "recharts" | "nivo";
+/** Nivo renderer; only the Nivo types honour it (Recharts is SVG only). */
+type ChartRenderer = "svg" | "canvas";
+/** One category with a numeric value per series. */
+type ChartRow = Record<string, string | number | null | undefined>;
+/** One series of points; x may be a category or a number, y a number. */
+interface ChartPoint {
+  x: string | number;
+  y: number | null;
+}
+interface ChartSeries {
+  id: string | number;
+  data: ChartPoint[];
+}
+/** One slice of a pie, donut or funnel. */
+interface ChartSlice {
+  id: string | number;
+  label?: string;
+  value: number;
+}
+/** One day of a calendar heatmap. */
+interface ChartDay {
+  day: string;
+  value: number;
+}
+/** A Nivo tree node for treemap and sunburst. */
+interface ChartTree {
+  id?: string | number;
+  name?: string;
+  value?: number;
+  children?: ChartTree[];
+  [key: string]: unknown;
+}
+/** The data type accepted for each chart type. */
+type ChartDataFor<T extends ChartType> = T extends "bar" | "radar" ? ChartRow[] | ChartSeries[] : T extends "line" | "area" ? ChartSeries[] | ChartRow[] : T extends "pie" | "donut" | "funnel" ? ChartSlice[] : T extends "scatter" | "scatterplot" | "heatmap" ? ChartSeries[] : T extends "calendar" ? ChartDay[] : T extends "treemap" | "sunburst" ? ChartTree : never;
+/**
+ * Per-series presentation, keyed by series id (the `keys` of a row chart, the
+ * `id` of a series or slice). Colours default to `var(--ds-viz-1..n)` in key
+ * order, so the same category index gets the same colour in every app; set
+ * `color` only to pin a category to a semantic colour, and then only to a
+ * token (`var(--ds-success)`), never a literal.
+ */
+type ChartConfig = Record<string, {
+  label?: React$1.ReactNode;
+  icon?: React$1.ComponentType;
+  color?: string;
+}>;
+/** Which continuous scale a heatmap or calendar uses. */
+type ChartScale = "sequential" | "diverging";
+export declare const RECHARTS_TYPES: ReadonlySet<ChartType>;
+export declare const NIVO_TYPES: ReadonlySet<ChartType>;
+/** The engine the package uses for a chart type. */
+export declare function chartEngine(type: ChartType): ChartEngine;
+//#endregion
+//#region src/components/chart/container.d.ts
+interface ChartContextValue {
+  config: ChartConfig;
+  /** The container element, so token resolution can honour a nested theme scope. */
+  element: HTMLDivElement | null;
+}
+/** The nearest ChartContainer's config and element; null outside one. */
+export declare function useChart(): ChartContextValue | null;
+/**
+ * Resolve the colour a series key paints with: `config[key].color` when set,
+ * otherwise `var(--ds-viz-N)` by the key's position in the config (or the
+ * `index` given). Recharts consumers reference it as `var(--color-<key>)`,
+ * which ChartContainer defines on its element.
+ */
+export declare function seriesColor(config: ChartConfig | undefined, key: string, index?: number): string;
+interface ChartContainerProps extends Omit<React$1.ComponentProps<"div">, "children"> {
+  /** Series presentation; colours default to `--ds-viz-1..n` in key order. */
+  config?: ChartConfig;
+  /** Height of the drawing area; width is always 100% of the parent. Default 300. */
+  height?: number | string;
+  /**
+   * Wrap children in Recharts' ResponsiveContainer (default). Nivo's
+   * `Responsive*` components size themselves, so the Nivo renderers pass
+   * `responsive={false}`.
+   */
+  responsive?: boolean;
+  children: React$1.ReactNode;
+}
+/**
+ * ChartContainer — the sized, token-styled surface every chart draws in.
+ *
+ * It defines `--color-<key>` for each config key (so Recharts parts can say
+ * `fill="var(--color-revenue)"`) and styles Recharts' axis, grid, tick and
+ * cursor classes from tokens with a caption-sm floor for text, so a custom
+ * chart composed inside it needs no local colours or fonts.
+ */
+declare function ChartContainer({ config, height, responsive, className, style, children, ...props }: ChartContainerProps): React$1.JSX.Element;
+/** "No data" placeholder; rendered by Chart when the data is empty. */
+declare function ChartEmpty({ children, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+/** Error placeholder; rendered by Chart for an `error` prop or a failed Nivo chunk. */
+declare function ChartError({ className, children, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+/** Loading placeholder: a skeleton the size of the drawing area, shown while a Nivo chunk loads. */
+declare function ChartLoading({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+interface ChartTooltipContentProps extends Partial<Pick<TooltipContentProps$1, "active" | "payload" | "label">> {
+  className?: string;
+  /** Hide the series label column. */
+  hideLabel?: boolean;
+  /** Hide the colour swatch. */
+  hideIndicator?: boolean;
+  /** Format a value; defaults to `toLocaleString`. */
+  formatter?: (value: number | string, name: string) => React$1.ReactNode;
+  /** Format the header (the category). */
+  labelFormatter?: (label: React$1.ReactNode) => React$1.ReactNode;
+}
+/**
+ * ChartTooltipContent — the popover body for Recharts' Tooltip, styled like
+ * the package Tooltip on the popover tokens. Pass as `content` to
+ * ChartTooltip; reads series labels and colours from the ChartContainer config.
+ */
+declare function ChartTooltipContent({ active, payload, label, className, hideLabel, hideIndicator, formatter, labelFormatter }: ChartTooltipContentProps): React$1.JSX.Element | null;
+/** Recharts' Tooltip with the token-styled content and a subtle cursor. */
+declare function ChartTooltip(props: TooltipProps): React$1.JSX.Element;
+interface ChartLegendContentProps {
+  payload?: readonly LegendPayload[];
+  verticalAlign?: "top" | "bottom" | "middle";
+  className?: string;
+  hideIcon?: boolean;
+}
+/** ChartLegendContent — Recharts' legend on tokens; reads labels from the config. */
+declare function ChartLegendContent({ payload, verticalAlign, className, hideIcon }: ChartLegendContentProps): React$1.JSX.Element | null;
+/** Recharts' Legend with the token-styled content. */
+declare function ChartLegend(props: LegendProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/chart/chart.d.ts
+interface ChartProps<T extends ChartType = ChartType> extends Omit<ChartContainerProps, "children" | "config" | "responsive"> {
+  /** Which chart to draw; the package picks the engine. See {@link ChartType} for the data shape per type. */
+  type: T;
+  /** The data, in the shape documented on {@link ChartType}. */
+  data: ChartDataFor<T>;
+  /** Series presentation keyed by series id; colours default to `--ds-viz-1..n` in order. */
+  config?: ChartConfig;
+  /** Nivo renderer; `canvas` for large series. Ignored by the Recharts types and by sunburst. */
+  renderer?: ChartRenderer;
+  /** Category key for row data (bar, line, area, radar); inferred as the first string field. */
+  indexBy?: string;
+  /** Series keys for row data; inferred as every numeric field. */
+  keys?: string[];
+  /** Stack bars and areas instead of grouping them. */
+  stacked?: boolean;
+  /** Continuous scale for heatmap and calendar. Default sequential. */
+  scale?: ChartScale;
+  /** Show a legend. Default: when there is more than one series. */
+  legend?: boolean;
+  /** Draw grid lines (cartesian and radar types). Default true. */
+  grid?: boolean;
+  /** Show a tooltip on hover. Default true. */
+  tooltip?: boolean;
+  /** Format values in axes, tooltips and labels. */
+  valueFormatter?: (value: number) => string;
+  /** Calendar range (ISO dates); defaults to the data's extent. */
+  from?: string;
+  to?: string;
+  /** Render the loading skeleton instead of the data. */
+  loading?: boolean;
+  /** Render the error state with this message instead of the data. */
+  error?: React$1.ReactNode | Error | null;
+  /** Content of the empty state. Default "No data". */
+  emptyMessage?: React$1.ReactNode;
+}
+/**
+ * Chart — one component for every chart type the fleet draws.
+ *
+ * `type` picks the engine: Recharts (bundled) for bar, line, area, pie, donut,
+ * scatter, radar and funnel; Nivo, lazy-loaded per package, for heatmap,
+ * calendar, treemap and sunburst, with `renderer="canvas"` for large series.
+ * Colours, fonts, axes, grid, tooltip, legend and the empty, loading and
+ * error states all come from cortena-design tokens; a consumer passes data
+ * and, optionally, a `config` of labels.
+ */
+declare function Chart<T extends ChartType>({ type, data, config, renderer, indexBy, keys, stacked, scale, legend, grid, tooltip, valueFormatter, from, to, loading, error, emptyMessage, className, height, ...props }: ChartProps<T>): React$1.JSX.Element;
+//#endregion
+//#region src/components/chart/nivo-theme.d.ts
+/**
+ * The Nivo theme object, typed structurally so no `@nivo/*` package is a
+ * static import of this module (the Nivo packages are lazy-loaded). It is a
+ * subset of `PartialTheme` from `@nivo/theming` and assignable to every
+ * chart's `theme` prop.
+ */
+interface NivoTheme {
+  background: string;
+  text: {
+    fontFamily: string;
+    fontSize: number;
+    fill: string;
+  };
+  axis: {
+    domain: {
+      line: {
+        stroke: string;
+        strokeWidth: number;
+      };
+    };
+    ticks: {
+      line: {
+        stroke: string;
+        strokeWidth: number;
+      };
+      text: {
+        fill: string;
+        fontSize: number;
+      };
+    };
+    legend: {
+      text: {
+        fill: string;
+        fontSize: number;
+        fontWeight: number;
+      };
+    };
+  };
+  grid: {
+    line: {
+      stroke: string;
+      strokeWidth: number;
+    };
+  };
+  crosshair: {
+    line: {
+      stroke: string;
+      strokeWidth: number;
+      strokeOpacity: number;
+      strokeDasharray: string;
+    };
+  };
+  legends: {
+    text: {
+      fill: string;
+      fontSize: number;
+    };
+    title: {
+      text: {
+        fill: string;
+        fontSize: number;
+      };
+    };
+    ticks: {
+      line: {
+        stroke: string;
+        strokeWidth: number;
+      };
+      text: {
+        fill: string;
+        fontSize: number;
+      };
+    };
+  };
+  labels: {
+    text: {
+      fill: string;
+      fontSize: number;
+      fontWeight: number;
+    };
+  };
+  dots: {
+    text: {
+      fill: string;
+      fontSize: number;
+    };
+  };
+  markers: {
+    lineColor: string;
+    lineStrokeWidth: number;
+    text: {
+      fill: string;
+      fontSize: number;
+    };
+  };
+  annotations: {
+    text: {
+      fill: string;
+      fontSize: number;
+      outlineWidth: number;
+      outlineColor: string;
+    };
+    link: {
+      stroke: string;
+      strokeWidth: number;
+      outlineWidth: number;
+      outlineColor: string;
+    };
+    outline: {
+      stroke: string;
+      strokeWidth: number;
+      outlineWidth: number;
+      outlineColor: string;
+    };
+    symbol: {
+      fill: string;
+      outlineWidth: number;
+      outlineColor: string;
+    };
+  };
+  tooltip: {
+    container: {
+      background: string;
+      color: string;
+      fontSize: number;
+      fontFamily: string;
+      borderRadius: number;
+      boxShadow: string;
+      border: string;
+      padding: string;
+    };
+    chip: {
+      borderRadius: number;
+    };
+  };
+}
+/**
+ * Build the Nivo theme from the tokens, resolved on `el` (default `<html>`).
+ * Every colour is read from a `--ds-*` custom property and converted to hex,
+ * because Nivo's canvas renderer and its colour derivation cannot read
+ * `var()`. Sizes come from the type scale with `--ds-text-caption-sm` (11px)
+ * as the floor for ticks and labels.
+ *
+ * Moved here from cortenaweb's webchat renderer; nothing is hard-coded.
+ */
+export declare function nivoTheme(el?: Element | null): NivoTheme;
+/**
+ * The Nivo theme for the current theme, re-resolved when `data-theme` or the
+ * OS scheme flips. Inside a ChartContainer the tokens are read on its element,
+ * so a nested theme scope is honoured.
+ */
+export declare function useNivoTheme(): NivoTheme;
+//#endregion
+//#region src/components/chart/tokens.d.ts
+/**
+ * Token plumbing for the chart engines.
+ *
+ * Recharts draws SVG, so it can take `var(--ds-viz-1)` verbatim and the
+ * browser resolves it. Nivo cannot: its canvas renderer hands colours to a
+ * 2D context, and its SVG renderer runs colours through d3-color for label and
+ * border derivation, and neither understands `var()`. So every Nivo value is
+ * read from the `--ds-*` custom property at runtime and handed over as a
+ * concrete hex. Nothing in this file is a literal; on the server (no DOM) the
+ * `var()` form is returned so SSR markup still resolves in the browser.
+ */
+/** Number of categorical series colours the design system defines (`--ds-viz-1..n`). */
+export declare const VIZ_SERIES_COUNT: number;
+/** `var(--ds-viz-N)` for a zero-based series index, wrapping past the palette. */
+export declare function vizVar(index: number): string;
+/** The categorical palette as `var()` references, in series order. */
+export declare const vizSeriesVars: readonly string[];
+/**
+ * Convert any CSS colour the browser understands (oklch, color-mix, rgba…) to
+ * `#rrggbb`, by painting it into an offscreen 2D context. Alpha is composited
+ * against transparent, so translucent tokens come back opaque; chart fills
+ * never use those.
+ */
+export declare function toHex(css: string): string | undefined;
+/**
+ * A token as a concrete colour. Returns hex in the browser; on the server the
+ * `var()` form, which is fine for SVG markup and irrelevant for canvas.
+ */
+export declare function resolveColor(token: string, el?: Element | null): string;
+/** The categorical palette resolved to concrete colours, in series order. */
+export declare function resolveVizSeries(el?: Element | null): string[];
+interface ChartScales {
+  /** Low → high, as concrete hex stops. */
+  sequential: string[];
+  /** Negative → neutral → positive, as concrete hex stops. */
+  diverging: string[];
+  /** Interpolators over the stops, `t` in [0, 1], for Nivo's `interpolator` configs. */
+  sequentialInterpolator: (t: number) => string;
+  divergingInterpolator: (t: number) => string;
+  /** `n` evenly spaced sequential swatches, for quantised fills like the calendar. */
+  sequentialSteps: (n: number) => string[];
+  /** Fill for cells with no value. */
+  empty: string;
+  /** The chart's surface (`--ds-background`), for the gaps between cells and arcs. */
+  surface: string;
+}
+/**
+ * Sequential and diverging scales from the tokens.
+ *
+ * The token set has only the eight categorical `--ds-viz-*` colours and no
+ * sequential ramp, so the sequential scale is derived from the
+ * `--ds-primary-100..900` ladder: light surfaces run 100 → 700 (pale to deep),
+ * dark surfaces run 900 → 400 (deep to bright), so low values sit near the
+ * background in both themes. The diverging scale runs `--ds-viz-5` (rose)
+ * through the theme's neutral (`--ds-neutral-200` light, `--ds-neutral-700`
+ * dark) to `--ds-viz-1` (blue).
+ */
+export declare function chartScales(el?: Element | null): ChartScales;
+//#endregion
+//#region src/components/data-table/features.d.ts
+declare const baseFeatures: {
+  columnFilteringFeature: import("@tanstack/react-table").TableFeature;
+  globalFilteringFeature: import("@tanstack/react-table").TableFeature;
+  columnFacetingFeature: import("@tanstack/react-table").TableFeature;
+  rowSortingFeature: import("@tanstack/react-table").TableFeature;
+  rowPaginationFeature: import("@tanstack/react-table").TableFeature;
+  rowSelectionFeature: import("@tanstack/react-table").TableFeature;
+  rowExpandingFeature: import("@tanstack/react-table").TableFeature;
+  columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
+  columnPinningFeature: import("@tanstack/react-table").TableFeature;
+  columnSizingFeature: import("@tanstack/react-table").TableFeature;
+  columnResizingFeature: import("@tanstack/react-table").TableFeature;
+  filteredRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  sortedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  paginatedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  expandedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  facetedRowModel: (table: import("@tanstack/react-table").Table<any, any>, columnId: string) => () => import("@tanstack/react-table").RowModel<any, any>;
+  facetedUniqueValues: (table: import("@tanstack/react-table").Table<import("@tanstack/react-table").TableFeatures, any>, columnId: string) => () => Map<any, number>;
+  filterFns: {
+    includesString: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    equals: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    equalsString: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    inNumberRange: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    arrIncludes: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    arrIncludesSome: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    inDateRange: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    weakEquals: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    oneOf: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+  };
+  sortFns: {
+    alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    basic: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    datetime: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    text: import("@tanstack/react-table").CreatedSortFn<any, any>;
+  };
+  columnMeta: DataTableColumnMeta<any>;
+};
+/**
+ * The registry type, re-keyed to the consumer's row type so `meta.onCommit`
+ * receives a typed row. The runtime object is the same for every table.
+ */
+type DataTableFeatures<Row extends RowData> = Omit<typeof baseFeatures, "columnMeta"> & {
+  columnMeta: DataTableColumnMeta<Row>;
+};
+export declare function dataTableFeatures<Row extends RowData>(): DataTableFeatures<Row>;
+/**
+ * `createColumnHelper` bound to the DataTable feature set. v9's helper takes
+ * the features as its first type argument; this saves consumers from
+ * importing the registry.
+ *
+ * @example
+ * const helper = createColumnHelper<Contact>();
+ * const columns = helper.columns([
+ *   helper.accessor("name", { header: "Name" }),
+ *   helper.accessor("status", { header: "Status", meta: { filter: "faceted" } }),
+ * ]);
+ */
+export declare function createColumnHelper<Row extends RowData>(): ColumnHelper<DataTableFeatures<Row>, Row>;
+//#endregion
+//#region src/components/data-table/types.d.ts
+/**
+ * Data sources (the contract in cortenaUI&Design/04-data-tables.md).
+ *
+ * A client source hands the table every row and lets it filter, sort and page
+ * in memory. A server source hands the table one page at a time: the table
+ * owns the search box, filter, sort and page state, turns it into a
+ * `TableQuery`, and the app answers with the already filtered, sorted page and
+ * the total. `TableQuery` / `TableResult` are also the backend contract every
+ * extension's list endpoint is expected to speak.
+ */
+type ClientSource<Row> = {
+  kind: "client";
+  rows: Row[];
+};
+type ServerSource<Row> = {
+  kind: "server";
+  /**
+   * Fetch one page. The optional `signal` is aborted when the query changes
+   * before the request settles, so a fetch that forwards it to `fetch()` is
+   * cancelled rather than raced.
+   */
+  fetch: (query: TableQuery, signal?: AbortSignal) => Promise<TableResult<Row>>;
+  /**
+   * TanStack Query cache scope. Two tables that share a key share pages;
+   * defaults to a key private to the component instance.
+   */
+  queryKey?: readonly unknown[];
+};
+type DataSource<Row> = ClientSource<Row> | ServerSource<Row>;
+type TableQuery = {
+  q?: string;
+  filters?: Array<{
+    id: string;
+    value: unknown;
+  }>;
+  sort?: Array<{
+    id: string;
+    desc: boolean;
+  }>;
+  page: number;
+  pageSize: number;
+};
+type TableResult<Row> = {
+  rows: Row[];
+  total: number;
+};
+/** Inline-editing options for a column (`meta.editable`). */
+interface DataTableEditable {
+  /** Input type; `number` parses the draft with `Number()` before commit. */
+  type?: "text" | "number";
+  /** Turn the raw input string into the committed value. */
+  parse?: (raw: string) => unknown;
+}
+/**
+ * Per-column `meta`. Typed through the v9 `columnMeta` feature slot, so
+ * `helper.accessor("x", { meta: { ... } })` is checked without declaration
+ * merging.
+ */
+interface DataTableColumnMeta<Row = unknown> {
+  /**
+   * Toolbar filter for this column. `faceted` renders a checkbox list of the
+   * column's distinct values (or `filterOptions`) and filters with `oneOf`.
+   */
+  filter?: "faceted" | "text";
+  /** Fixed facet options; required for a server source, where only one page is loaded. */
+  filterOptions?: Array<{
+    value: string | number | boolean;
+    label?: string;
+    icon?: React.ComponentType<{
+      className?: string;
+    }>;
+  }>;
+  /** Text alignment of the header and cells. Numbers usually want `end`. */
+  align?: "start" | "center" | "end";
+  /** Enter or double-click opens an editor; Enter commits, Escape cancels. */
+  editable?: boolean | DataTableEditable;
+  /** Receives the committed value. Falls back to the table's `onCellCommit`. */
+  onCommit?: (row: Row, columnId: string, value: unknown) => void | Promise<void>;
+  /** Column label for the view menu and exports when `header` is not a string. */
+  label?: string;
+  /** Set `false` to leave the column out of CSV / Excel exports. */
+  exportable?: boolean;
+  /** Value written to exports instead of the accessor value. */
+  exportValue?: (row: Row) => string | number | boolean | Date | null | undefined;
+  /** Extra classes for every cell in this column. */
+  cellClassName?: string;
+  /** Extra classes for the header cell. */
+  headerClassName?: string;
+}
+type DataTableColumnDef<Row extends RowData, Value = unknown> = ColumnDef<DataTableFeatures<Row>, Row, Value>;
+type DataTableColumn<Row extends RowData, Value = unknown> = Column<DataTableFeatures<Row>, Row, Value>;
+type DataTableRow<Row$1 extends RowData> = Row<DataTableFeatures<Row$1>, Row$1>;
+type DataTableCell<Row extends RowData, Value = unknown> = Cell$2<DataTableFeatures<Row>, Row, Value>;
+type DataTableState<Row extends RowData> = TableState<DataTableFeatures<Row>>;
+/** The TanStack table instance every part takes as `table`. */
+type DataTableTable<Row extends RowData> = ReactTable<DataTableFeatures<Row>, Row>;
+type DataTablePaginationMode = "pages" | "infinite" | "none";
+interface UseDataTableOptions<Row extends RowData> {
+  columns: ReadonlyArray<DataTableColumnDef<Row, any>>;
+  dataSource: DataSource<Row>;
+  /** Stable row identity; defaults to the row index. Needed for selection and editing to survive re-sorts. */
+  getRowId?: (row: Row, index: number) => string;
+  /** Tree data: return a row's children. */
+  getSubRows?: (row: Row, index: number) => Row[] | undefined;
+  /** `pages` (default) renders a pager; `infinite` appends pages on scroll; `none` shows every row. */
+  pagination?: DataTablePaginationMode;
+  /** @default 25 */
+  pageSize?: number;
+  /** Adds a checkbox column and enables `bulkActions`. */
+  enableRowSelection?: boolean | ((row: DataTableRow<Row>) => boolean);
+  /** Adds an expander column; set automatically by `renderSubComponent`. */
+  enableExpanding?: boolean;
+  getRowCanExpand?: (row: DataTableRow<Row>) => boolean;
+  /** @default true */
+  enableSorting?: boolean;
+  /** @default false */
+  enableMultiSort?: boolean;
+  /** @default true */
+  enableGlobalFilter?: boolean;
+  /** @default true */
+  enableColumnFilters?: boolean;
+  /** @default true */
+  enableHiding?: boolean;
+  /** @default true */
+  enableColumnPinning?: boolean;
+  /** @default false */
+  enableColumnResizing?: boolean;
+  /** Starting sort, filters, visibility, pinning, sizing. */
+  initialState?: Partial<DataTableState<Row>>;
+  /** Table-wide commit handler for editable cells without their own `meta.onCommit`. */
+  onCellCommit?: (row: Row, columnId: string, value: unknown) => void | Promise<void>;
+  /** Fires with the selected original rows whenever selection changes. */
+  onRowSelectionChange?: (rows: Row[]) => void;
+  /** Debounce applied to the search box before it reaches a server source. @default 250 */
+  searchDebounceMs?: number;
+}
+interface DataTableEditingCell {
+  rowId: string;
+  columnId: string;
+}
+interface DataTableInstance<Row extends RowData> {
+  table: DataTableTable<Row>;
+  dataSource: DataSource<Row>;
+  paginationMode: DataTablePaginationMode;
+  /** Rows currently in the table (the page, for a server source). */
+  rows: Row[];
+  /** Total matching rows (server `total`, or the filtered count for a client source). */
+  total: number;
+  /** True until the first server page arrives; never true for a client source. */
+  isLoading: boolean;
+  /** True while any server request is in flight, including background refetches. */
+  isFetching: boolean;
+  error: Error | null;
+  refetch: () => void;
+  /** Infinite mode: load the next page. No-op elsewhere. */
+  fetchNextPage: () => void;
+  hasNextPage: boolean;
+  /** Search text the server last received (debounced), for consumers rendering their own toolbar. */
+  searchQuery: string;
+  editing: {
+    cell: DataTableEditingCell | null;
+    start: (cell: DataTableEditingCell) => void;
+    stop: () => void;
+    commit: (row: DataTableRow<Row>, columnId: string, value: unknown) => Promise<void>;
+  };
+}
+//#endregion
+//#region src/components/data-table/data-table.d.ts
+interface DataTableViewProps<Row extends RowData> {
+  className?: string;
+  /** Height of the scrolling body. Required for virtualisation to mean anything; defaults to 600px when virtualised. */
+  maxHeight?: number | string;
+  /** Force virtualisation on or off; undefined virtualises above 100 rows. */
+  virtualize?: boolean;
+  /** Estimated row height in px for the virtualizer. @default 40 */
+  rowHeight?: number;
+  /** @default true */
+  stickyHeader?: boolean;
+  /** @default "default" */
+  density?: "default" | "compact";
+  /** Detail panel under an expanded row; enables the expander column. */
+  renderSubComponent?: (row: DataTableRow<Row>) => React$1.ReactNode;
+  /** `false` hides the toolbar; a function replaces it. */
+  toolbar?: boolean | ((ctx: {
+    instance: DataTableInstance<Row>;
+  }) => React$1.ReactNode);
+  /** Rendered in the toolbar while rows are selected. */
+  bulkActions?: (ctx: {
+    rows: Row[];
+    table: DataTableTable<Row>;
+  }) => React$1.ReactNode;
+  /** Extra toolbar controls (right side). */
+  toolbarActions?: React$1.ReactNode;
+  searchPlaceholder?: string;
+  emptyState?: React$1.ReactNode;
+  /** @default "No results" */
+  emptyMessage?: string;
+  pageSizeOptions?: number[];
+  /** @default true */
+  enableExport?: boolean;
+  /** @default "export" */
+  exportFileName?: string;
+  /** Show the loading skeleton regardless of the source's own state. */
+  loading?: boolean;
+  /** Error to show above the table, in addition to the server source's. */
+  error?: string | Error | null;
+  onRowClick?: (row: Row, event: React$1.MouseEvent<HTMLTableRowElement>) => void;
+}
+type DataTableProps<Row extends RowData> = DataTableViewProps<Row> & ({
+  instance: DataTableInstance<Row>;
+} | UseDataTableOptions<Row>);
+declare function DataTable<Row extends RowData>(props: DataTableProps<Row>): React$1.JSX.Element;
+declare function DataTableView<Row extends RowData>({ instance, className, maxHeight, virtualize, rowHeight, stickyHeader, density, renderSubComponent, toolbar, bulkActions, toolbarActions, searchPlaceholder, emptyState, emptyMessage, pageSizeOptions, enableExport, exportFileName, loading, error, onRowClick }: DataTableViewProps<Row> & {
+  instance: DataTableInstance<Row>;
+}): React$1.JSX.Element;
+//#endregion
+//#region src/components/data-table/parts.d.ts
+interface DataTableColumnHeaderProps<Row extends RowData> extends Omit<React$1.ComponentProps<"div">, "title"> {
+  column: DataTableColumn<Row, any>;
+  title: React$1.ReactNode;
+}
+/**
+ * Header content for one column: the title as a sort toggle when the column
+ * sorts, and a menu with sort, pin and hide when any of those apply. The
+ * table renders it for every string `header` automatically; use it inside a
+ * custom header function to keep the same affordances.
+ */
+declare function DataTableColumnHeader<Row extends RowData>({ column, title, className, ...props }: DataTableColumnHeaderProps<Row>): React$1.JSX.Element;
+interface DataTableFacetedFilterOption {
+  value: string | number | boolean;
+  label?: string;
+  icon?: React$1.ComponentType<{
+    className?: string;
+  }>;
+}
+interface DataTableFacetedFilterProps<Row extends RowData> {
+  column: DataTableColumn<Row, any>;
+  title?: React$1.ReactNode;
+  /** Fixed options; defaults to the column's distinct values with counts (client source only). */
+  options?: DataTableFacetedFilterOption[];
+  className?: string;
+}
+/**
+ * A checkbox list of a column's values. The filter value is the array of
+ * picked values; the column's `filterFn` (`oneOf` by default for
+ * `meta.filter: "faceted"`) decides what that means, and a server source
+ * receives it verbatim in `TableQuery.filters`.
+ */
+declare function DataTableFacetedFilter<Row extends RowData>({ column, title, options, className }: DataTableFacetedFilterProps<Row>): React$1.JSX.Element;
+interface DataTableViewOptionsProps<Row extends RowData> {
+  table: DataTableTable<Row>;
+  className?: string;
+}
+/** Column visibility menu. */
+declare function DataTableViewOptions<Row extends RowData>({ table, className }: DataTableViewOptionsProps<Row>): React$1.JSX.Element | null;
+interface DataTableExportMenuProps<Row extends RowData> {
+  table: DataTableTable<Row>;
+  fileName?: string;
+  className?: string;
+}
+declare function DataTableExportMenu<Row extends RowData>({ table, fileName, className }: DataTableExportMenuProps<Row>): React$1.JSX.Element;
+interface DataTableToolbarProps<Row extends RowData> extends Omit<React$1.ComponentProps<"div">, "children"> {
+  table: DataTableTable<Row>;
+  /** Placeholder for the search box. @default "Search…" */
+  searchPlaceholder?: string;
+  /** Rendered while rows are selected, in place of the filters. */
+  bulkActions?: (ctx: {
+    rows: Row[];
+    table: DataTableTable<Row>;
+  }) => React$1.ReactNode;
+  /** Extra controls on the right, before the view and export menus. */
+  children?: React$1.ReactNode;
+  /** @default true */
+  enableExport?: boolean;
+  exportFileName?: string;
+}
+/**
+ * Search box, one faceted filter per `meta.filter: "faceted"` column, a reset
+ * when anything is filtered, and the view / export menus. While rows are
+ * selected the left side becomes the selection summary and `bulkActions`.
+ */
+declare function DataTableToolbar<Row extends RowData>({ table, searchPlaceholder, bulkActions, children, enableExport, exportFileName, className, ...props }: DataTableToolbarProps<Row>): React$1.JSX.Element;
+interface DataTablePaginationProps<Row extends RowData> extends React$1.ComponentProps<"div"> {
+  table: DataTableTable<Row>;
+  /** @default [10, 25, 50, 100] */
+  pageSizeOptions?: number[];
+}
+declare function DataTablePagination<Row extends RowData>({ table, pageSizeOptions, className, ...props }: DataTablePaginationProps<Row>): React$1.JSX.Element;
+//#endregion
+//#region src/components/data-table/use-data-table.d.ts
+/**
+ * Builds the table for a `dataSource`. This is where the design decision's
+ * "the component sets the manual flags itself" lives: a server source flips
+ * `manualFiltering`, `manualSorting` and `manualPagination` and feeds the
+ * table's own filter / sort / page state back out as a `TableQuery`; a client
+ * source leaves every row model in memory. Everything else (selection,
+ * expansion, visibility, pinning, sizing) is owned by the table.
+ *
+ * Use it directly when the default layout is not enough: pass the returned
+ * `table` to `DataTableToolbar`, `DataTablePagination` and friends, or the
+ * whole instance to `<DataTable instance={...} />`.
+ */
+export declare function useDataTable<Row extends RowData>(options: UseDataTableOptions<Row>): DataTableInstance<Row>;
+//#endregion
+//#region src/components/data-table/export.d.ts
+type ExportCell = string | number | boolean | Date | null;
+interface ExportSheet {
+  headers: string[];
+  records: ExportCell[][];
+}
+export declare function toSheet<Row extends RowData>(table: DataTableTable<Row>, rows?: DataTableRow<Row>[]): ExportSheet;
+/** RFC 4180 text: comma separated, CRLF lines, quotes doubled. */
+export declare function toCsv<Row extends RowData>(table: DataTableTable<Row>, rows?: DataTableRow<Row>[]): string;
+export declare function downloadCsv<Row extends RowData>(table: DataTableTable<Row>, fileName?: string, rows?: DataTableRow<Row>[]): void;
+/**
+ * Excel through exceljs, loaded on first use so the workbook code (about
+ * 300 KB) never sits in a bundle that only ever exports CSV.
+ */
+export declare function downloadExcel<Row extends RowData>(table: DataTableTable<Row>, fileName?: string, rows?: DataTableRow<Row>[]): Promise<void>;
+//#endregion
+//#region src/components/accordion.d.ts
+/**
+ * Accordion.
+ *
+ * Base UI's Accordion is a list of Collapsibles: `Root > Item > Header > Trigger`
+ * plus `Panel`. The panel animates on height through Base UI's
+ * `--accordion-panel-height`, and marks its first/last frame with
+ * `data-starting-style` / `data-ending-style`, which is where it collapses to 0.
+ *
+ * Radix users: `type="single" | "multiple"` is now the boolean `multiple`, and
+ * `value` is always an array. `collapsible` is the default. `data-state="open"`
+ * is `data-open` on the item and panel, `data-panel-open` on the trigger.
+ */
+declare function Accordion({ className, ...props }: Accordion$1.Root.Props): import("react").JSX.Element;
+declare function AccordionItem({ className, ...props }: Accordion$1.Item.Props): import("react").JSX.Element;
+declare function AccordionTrigger({ className, children, ...props }: Accordion$1.Trigger.Props): import("react").JSX.Element;
+declare function AccordionContent({ className, children, ...props }: Accordion$1.Panel.Props): import("react").JSX.Element;
+//#endregion
+//#region src/components/alert.d.ts
+/**
+ * Alert — an inline callout. Tinted variants use the `-soft` fill for the
+ * background and the tone colour for the border and icon; the body text stays
+ * on the foreground token so it reads in both themes.
+ */
+declare const alertVariants: (props?: ({
+  variant?: "default" | "success" | "warn" | "danger" | "info" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface AlertProps extends React$1.ComponentProps<"div">, VariantProps<typeof alertVariants> {}
+declare function Alert({ className, variant, ...props }: AlertProps): React$1.JSX.Element;
+declare function AlertIcon({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function AlertTitle({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function AlertDescription({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+//#endregion
+//#region src/components/avatar.d.ts
+/**
+ * Avatar.
+ *
+ * Base UI preloads the image and only mounts `<img>` once it has loaded, so
+ * the fallback is what paints while loading and after an error. Initials sit
+ * on the primary fill in inverse text.
+ *
+ * Radix users: `delayMs` on the fallback is now `delay`.
+ */
+declare function Avatar({ className, ...props }: Avatar$1.Root.Props): import("react").JSX.Element;
+declare function AvatarImage({ className, ...props }: Avatar$1.Image.Props): import("react").JSX.Element;
+declare function AvatarFallback({ className, ...props }: Avatar$1.Fallback.Props): import("react").JSX.Element;
+//#endregion
+//#region src/components/badge.d.ts
+/**
+ * Badge — the mono, uppercase status label. Each tone pairs a `-soft` fill
+ * with its foreground token; `warn`, `danger` and `secondary` are aliases kept
+ * for cortenaweb call sites.
+ */
+declare const badgeVariants: (props?: ({
+  variant?: "secondary" | "outline" | "destructive" | "default" | "success" | "warn" | "danger" | "info" | "warning" | "neutral" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface BadgeProps extends React$1.ComponentProps<"span">, VariantProps<typeof badgeVariants> {}
+declare function Badge({ className, variant, ...props }: BadgeProps): React$1.JSX.Element;
+//#endregion
 //#region src/components/button.d.ts
 /**
  * Button.
@@ -25,8 +915,1118 @@ declare const buttonVariants: (props?: ({
   variant?: "primary" | "secondary" | "outline" | "ghost" | "soft" | "destructive" | "link" | null | undefined;
   size?: "sm" | "md" | "lg" | "icon" | "icon-sm" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
-interface ButtonProps extends React.ComponentProps<typeof Button$1>, VariantProps<typeof buttonVariants> {}
-declare function Button({ className, variant, size, ...props }: ButtonProps): React.JSX.Element;
+interface ButtonProps extends React$1.ComponentProps<typeof Button$1>, VariantProps<typeof buttonVariants> {}
+declare function Button({ className, variant, size, ...props }: ButtonProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/calendar.d.ts
+/**
+ * Calendar.
+ *
+ * The shadcn Calendar shape over react-day-picker 10. The library's stylesheet
+ * is not imported; every class comes from the `classNames` map below and every
+ * visual value in it is a cortena-design token. Structure (nav, caption, grid,
+ * dropdown caption) is DayPicker's; the day cells, nav buttons and chevrons are
+ * swapped for our Button and lucide icons through `components`.
+ *
+ * `showOutsideDays` defaults to true and `captionLayout` to `"label"`; pass
+ * `captionLayout="dropdown"` for native month/year selects in the caption.
+ */
+type CalendarProps = DayPickerProps;
+/**
+ * One day cell's button. Selection and range state are exposed as data
+ * attributes so the classes below (and a consumer's) can paint them; the
+ * `today` attribute is only set when the day is not selected, so the soft
+ * fill never competes with the selected fill.
+ */
+declare function CalendarDayButton({ className, day, modifiers, ...props }: DayButtonProps): React$1.JSX.Element;
+declare function Calendar({ className, classNames, components, showOutsideDays, captionLayout, formatters, ...props }: CalendarProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/card.d.ts
+interface CardProps extends React$1.ComponentProps<"div"> {
+  /** Lift the border and surface on hover, for clickable cards. */
+  hover?: boolean;
+  /** Draw the border in the ring colour, for a selected or highlighted card. */
+  accent?: boolean;
+}
+declare function Card({ className, hover, accent, ...props }: CardProps): React$1.JSX.Element;
+declare function CardHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function CardTitle({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function CardDescription({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function CardContent({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function CardFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+//#endregion
+//#region src/components/checkbox.d.ts
+/**
+ * Checkbox.
+ *
+ * Base UI renders a `<span role="checkbox">` with a hidden `<input>` beside
+ * it, so it submits with forms and takes `checked`/`defaultChecked`. The
+ * indicator only mounts while checked or indeterminate; the icon inside it is
+ * a lucide Check, or a Minus when `indeterminate` is set.
+ *
+ * The 16px box takes half the small radius: the 8px ladder step would round
+ * it into a circle.
+ */
+interface CheckboxProps extends React$1.ComponentProps<typeof Checkbox$1.Root> {}
+declare function Checkbox({ className, indeterminate, ...props }: CheckboxProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/chip.d.ts
+/**
+ * Chip — a pill for filters, tags and selected values. Unlike Badge it keeps
+ * sentence case and the body font.
+ */
+declare const chipVariants: (props?: ({
+  variant?: "outline" | "default" | "accent" | null | undefined;
+  size?: "sm" | "default" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface ChipProps extends React$1.ComponentProps<"span">, VariantProps<typeof chipVariants> {}
+declare function Chip({ className, variant, size, ...props }: ChipProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/combobox.d.ts
+/**
+ * Combobox: a filterable text input with a listbox popup, on Base UI.
+ *
+ * Give the Root `items` (an array, or `[{ value, label }]`) and render the
+ * list with `<ComboboxList>{(item) => <ComboboxItem value={item} />}</ComboboxList>`;
+ * Base UI filters `items` against the input as the user types. Without
+ * `items` nothing is filtered and `ComboboxEmpty` never shows.
+ *
+ * - `ComboboxInput` is our `Input` with a trailing open/close trigger and,
+ *   with `clearable`, an X button that clears the value.
+ * - `ComboboxContent` composes Portal + Positioner + Popup + List so
+ *   consumers write one element; positioning props go to the Positioner.
+ * - Multiple selection: set `multiple` on the Root and wrap `ComboboxValue`
+ *   (rendering a `ComboboxChip` per value) plus `ComboboxInput` in
+ *   `ComboboxChips`. Inside `ComboboxChips` the input drops its own frame;
+ *   the chips container carries the field look and anchors the popup.
+ * - `useComboboxFilter` is Base UI's `useFilter` for external filtering via
+ *   `filteredItems`.
+ *
+ * `onValueChange` receives `(value, eventDetails)`; `onInputValueChange`
+ * reports the typed text.
+ */
+declare function Combobox<Value, Multiple extends boolean | undefined = false, Item = Value>(props: Combobox$1.Root.Props<Value, Multiple, Item>): import("react").JSX.Element;
+declare function ComboboxTrigger({ className, children, ...props }: Combobox$1.Trigger.Props): import("react").JSX.Element;
+declare function ComboboxClear({ className, children, ...props }: Combobox$1.Clear.Props): import("react").JSX.Element;
+interface ComboboxInputProps extends Combobox$1.Input.Props {
+  /** Show an X button that clears the selection while there is one. */
+  clearable?: boolean;
+  /** Class for the wrapper that holds the input and its buttons. */
+  wrapperClassName?: string;
+}
+declare function ComboboxInput({ className, clearable, wrapperClassName, ...props }: ComboboxInputProps): import("react").JSX.Element;
+declare function ComboboxValue(props: Combobox$1.Value.Props): import("react").JSX.Element;
+interface ComboboxChipsProps extends Combobox$1.Chips.Props {
+  /** Class for the inner chip row; `className` styles the field frame. */
+  chipsClassName?: string;
+}
+declare function ComboboxChips({ className, chipsClassName, children, ...props }: ComboboxChipsProps): import("react").JSX.Element;
+interface ComboboxChipProps extends Combobox$1.Chip.Props {
+  /** Hide the remove button. */
+  removable?: boolean;
+}
+declare function ComboboxChip({ className, children, removable, ...props }: ComboboxChipProps): import("react").JSX.Element;
+type PositionerProps$4 = Pick<Combobox$1.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor" | "collisionBoundary" | "collisionPadding" | "collisionAvoidance" | "sticky" | "positionMethod">;
+interface ComboboxContentProps extends Omit<Combobox$1.Popup.Props, "children">, PositionerProps$4 {
+  /** Items, or a render function called per filtered item (needs `items` on the Root). */
+  children?: Combobox$1.List.Props["children"];
+  /**
+   * Shown (via `ComboboxEmpty`, above the list) when nothing matches the query.
+   * Needs `items` on the Root.
+   */
+  empty?: ReactNode;
+  /** Class for the inner List element. */
+  listClassName?: string;
+  /** Keep the popup mounted in the DOM while hidden. */
+  keepMounted?: boolean;
+  /** Where to portal the popup; defaults to `<body>`. */
+  container?: Combobox$1.Portal.Props["container"];
+}
+declare function ComboboxContent({ className, children, empty, listClassName, side, align, sideOffset, alignOffset, anchor, collisionBoundary, collisionPadding, collisionAvoidance, sticky, positionMethod, keepMounted, container, ...props }: ComboboxContentProps): import("react").JSX.Element;
+declare function ComboboxItem({ className, children, ...props }: Combobox$1.Item.Props): import("react").JSX.Element;
+/** Renders per filtered item; use inside a `ComboboxGroup` given `items`, or for a flat list pass a function as `ComboboxContent` children instead. */
+declare function ComboboxCollection(props: Combobox$1.Collection.Props): import("react").JSX.Element;
+declare function ComboboxEmpty({ className, ...props }: Combobox$1.Empty.Props): import("react").JSX.Element;
+declare function ComboboxStatus({ className, ...props }: Combobox$1.Status.Props): import("react").JSX.Element;
+declare function ComboboxGroup({ className, ...props }: Combobox$1.Group.Props): import("react").JSX.Element;
+declare function ComboboxGroupLabel({ className, ...props }: Combobox$1.GroupLabel.Props): import("react").JSX.Element;
+declare function ComboboxSeparator({ className, ...props }: Combobox$1.Separator.Props): import("react").JSX.Element;
+declare const useComboboxFilter: typeof Combobox$1.useFilter;
+//#endregion
+//#region src/components/dialog.d.ts
+/**
+ * Dialog.
+ *
+ * `DialogContent` composes Base UI's Portal + Backdrop + Popup so consumers
+ * keep writing `<DialogContent>…</DialogContent>`. The Radix `Overlay` part is
+ * exported as `DialogOverlay` (a styled Backdrop) for anyone composing by hand.
+ *
+ * Radix users: `asChild` becomes `render={...}`; `onOpenChange` receives
+ * `(open, eventDetails)` rather than just `open`; the popup is only
+ * dismissable via pointer when `modal` is true (the default), and
+ * `disablePointerDismissal` replaces `onPointerDownOutside` preventDefault.
+ */
+declare function Dialog(props: Dialog$1.Root.Props): React$1.JSX.Element;
+declare function DialogTrigger(props: Dialog$1.Trigger.Props): React$1.JSX.Element;
+declare function DialogPortal(props: Dialog$1.Portal.Props): React$1.JSX.Element;
+declare function DialogClose(props: Dialog$1.Close.Props): React$1.JSX.Element;
+declare function DialogOverlay({ className, ...props }: Dialog$1.Backdrop.Props): React$1.JSX.Element;
+interface DialogContentProps extends Dialog$1.Popup.Props {
+  /** Keep the dialog mounted in the DOM while hidden. */
+  keepMounted?: boolean;
+  /** Where to portal the dialog; defaults to `<body>`. */
+  container?: Dialog$1.Portal.Props["container"];
+}
+declare function DialogContent({ className, children, keepMounted, container, ...props }: DialogContentProps): React$1.JSX.Element;
+declare function DialogHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function DialogBody({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function DialogFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function DialogTitle({ className, ...props }: Dialog$1.Title.Props): React$1.JSX.Element;
+declare function DialogDescription({ className, ...props }: Dialog$1.Description.Props): React$1.JSX.Element;
+//#endregion
+//#region src/components/command.d.ts
+/**
+ * Command palette on cmdk, styled like DropdownMenu.
+ *
+ * cmdk filters and ranks items itself from each item's text (or `value` /
+ * `keywords`); `CommandEmpty` renders when nothing matches. The selected
+ * (keyboard-highlighted) item carries `data-selected="true"`; `onSelect` on
+ * `CommandItem` fires on click and on Enter.
+ *
+ * `CommandDialog` puts a palette inside our Dialog with no header padding;
+ * it needs a `title` (visually hidden) so the dialog is labelled. Wire
+ * `open` / `onOpenChange` to a global shortcut (⌘K) for the usual pattern.
+ */
+declare function Command({ className, ...props }: React$1.ComponentProps<typeof Command$1>): React$1.JSX.Element;
+interface CommandDialogProps extends React$1.ComponentProps<typeof Dialog> {
+  /** Accessible name for the dialog; visually hidden. */
+  title?: string;
+  /** Accessible description for the dialog; visually hidden. */
+  description?: string;
+  /** Class for the dialog popup. */
+  className?: string;
+  /** Class for the inner Command root. */
+  commandClassName?: string;
+  /** Where to portal the dialog; defaults to `<body>`. */
+  container?: DialogContentProps["container"];
+  /** Keep the dialog mounted in the DOM while hidden. */
+  keepMounted?: boolean;
+  /** Props for the inner cmdk root (`filter`, `shouldFilter`, `loop`, `value`, ...). */
+  commandProps?: Omit<React$1.ComponentProps<typeof Command$1>, "children" | "className">;
+  children?: React$1.ReactNode;
+}
+declare function CommandDialog({ title, description, className, commandClassName, container, keepMounted, commandProps, children, ...props }: CommandDialogProps): React$1.JSX.Element;
+declare function CommandInput({ className, ...props }: React$1.ComponentProps<typeof Command$1.Input>): React$1.JSX.Element;
+declare function CommandList({ className, ...props }: React$1.ComponentProps<typeof Command$1.List>): React$1.JSX.Element;
+declare function CommandEmpty({ className, ...props }: React$1.ComponentProps<typeof Command$1.Empty>): React$1.JSX.Element;
+declare function CommandGroup({ className, ...props }: React$1.ComponentProps<typeof Command$1.Group>): React$1.JSX.Element;
+declare function CommandSeparator({ className, ...props }: React$1.ComponentProps<typeof Command$1.Separator>): React$1.JSX.Element;
+interface CommandItemProps extends React$1.ComponentProps<typeof Command$1.Item> {
+  variant?: "default" | "destructive";
+}
+declare function CommandItem({ className, variant, ...props }: CommandItemProps): React$1.JSX.Element;
+declare function CommandShortcut({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+declare function CommandLoading(props: React$1.ComponentProps<typeof Command$1.Loading>): React$1.JSX.Element;
+//#endregion
+//#region src/components/date-field.d.ts
+/** `2026-01-05`. */
+declare function formatDateISO(date: Date): string;
+/** `5 Jan 2026` for en-GB; other locales via `Intl.DateTimeFormat`. */
+declare function formatDateShort(date: Date, locale?: string): string;
+/** `5 January 2026` for en-GB; other locales via `Intl.DateTimeFormat`. */
+declare function formatDateLong(date: Date, locale?: string): string;
+/**
+ * Calendar-day distance in words: `today`, `yesterday`, `tomorrow`, `3 days
+ * ago`, `in 2 weeks`, `4 months ago`, `in 2 years`. Compares local calendar
+ * days, so 23:59 to 00:01 is `tomorrow`. Other locales use
+ * `Intl.RelativeTimeFormat`.
+ */
+declare function formatRelative(date: Date, options?: {
+  now?: Date;
+  locale?: string;
+}): string;
+/** Strict `yyyy-mm-dd`; rejects impossible days such as `2026-02-30`. */
+declare function parseDateISO(text: string): Date | undefined;
+/** ISO first, then the English `5 Jan 2026` / `5 January 2026` shapes. */
+declare function parseDateDefault(text: string): Date | undefined;
+type CalendarPassthrough$1 = Omit<CalendarProps, "mode" | "selected" | "onSelect" | "required" | "disabled">;
+interface DateFieldProps extends Omit<React$1.ComponentProps<"input">, "value" | "defaultValue" | "onChange" | "min" | "max" | "type"> {
+  /** The date (controlled). */
+  value?: Date | undefined;
+  /** The initial date (uncontrolled). */
+  defaultValue?: Date | undefined;
+  /** Called with the parsed or picked date, or `undefined` when the text is cleared or invalid. */
+  onValueChange?: (date: Date | undefined) => void;
+  /** Input placeholder; defaults to the ISO shape. */
+  placeholder?: string;
+  /** Formats the date into the input; defaults to ISO `yyyy-mm-dd`. */
+  formatDate?: (date: Date) => string;
+  /** Parses typed text; defaults to ISO plus the English day-month-year shapes. */
+  parseDate?: (text: string) => Date | undefined;
+  /** Earliest selectable day. */
+  min?: Date;
+  /** Latest selectable day. */
+  max?: Date;
+  disabled?: boolean;
+  /** Force the invalid look (e.g. from a form validator). */
+  invalid?: boolean;
+  /** Extra props for the Calendar (e.g. `captionLayout`, `today`). */
+  calendarProps?: CalendarPassthrough$1;
+  /** Class name for the wrapper; use `className` for the input itself. */
+  wrapperClassName?: string;
+}
+declare function DateField(props: DateFieldProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/date-picker.d.ts
+/** en-GB order, no library: `15 January 2026`. */
+declare function formatDateDefault(date: Date): string;
+type CalendarPassthrough = Omit<CalendarProps, "mode" | "selected" | "onSelect" | "required" | "disabled">;
+interface DatePickerProps {
+  /** The selected date (controlled). */
+  value?: Date | undefined;
+  /** The initial date (uncontrolled). */
+  defaultValue?: Date | undefined;
+  /** Called with the picked date, or `undefined` when the selected day is clicked again. */
+  onValueChange?: (date: Date | undefined) => void;
+  /** Trigger text while nothing is selected. */
+  placeholder?: string;
+  /** Formats the trigger text; defaults to `15 January 2026`. */
+  formatDate?: (date: Date) => string;
+  /** Disables the trigger. */
+  disabled?: boolean;
+  /** Class name for the trigger button. */
+  className?: string;
+  /** Extra props for the Calendar (e.g. `startMonth`, `captionLayout`, `disabled` matchers via `calendarProps.hidden`). */
+  calendarProps?: CalendarPassthrough & {
+    disabled?: CalendarProps["disabled"];
+  };
+  /** Accessible name for the trigger. */
+  "aria-label"?: string;
+}
+declare function DatePicker(props: DatePickerProps): React$1.JSX.Element;
+interface DateRangePickerProps extends Omit<DatePickerProps, "value" | "defaultValue" | "onValueChange"> {
+  value?: DateRange | undefined;
+  defaultValue?: DateRange | undefined;
+  onValueChange?: (range: DateRange | undefined) => void;
+  /** Separator between the two ends; defaults to an en dash. */
+  separator?: string;
+}
+declare function DateRangePicker(props: DateRangePickerProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/dropdown-menu.d.ts
+/**
+ * DropdownMenu over Base UI's Menu.
+ *
+ * `DropdownMenuContent` and `DropdownMenuSubContent` compose Portal +
+ * Positioner + Popup, so consumers keep writing one element; `side`, `align`
+ * and `sideOffset` are forwarded to the Positioner where Base UI reads them.
+ *
+ * Radix users: `asChild` on the trigger becomes `render={<Button />}`;
+ * `onSelect` on items is `onClick`; `DropdownMenuLabel` is Base UI's
+ * `Menu.GroupLabel` (place it inside a `DropdownMenuGroup` for the
+ * `aria-labelledby` wiring); `DropdownMenuCheckboxItem` reports through
+ * `onCheckedChange(checked, eventDetails)`; `DropdownMenuRadioGroup` through
+ * `onValueChange(value, eventDetails)`. Highlight state is `data-highlighted`,
+ * not `:focus`.
+ */
+declare function DropdownMenu(props: Menu.Root.Props): React$1.JSX.Element;
+declare function DropdownMenuTrigger(props: Menu.Trigger.Props): React$1.JSX.Element;
+declare function DropdownMenuPortal(props: Menu.Portal.Props): React$1.JSX.Element;
+declare function DropdownMenuGroup(props: Menu.Group.Props): React$1.JSX.Element;
+declare function DropdownMenuSub(props: Menu.SubmenuRoot.Props): React$1.JSX.Element;
+declare function DropdownMenuRadioGroup(props: Menu.RadioGroup.Props): React$1.JSX.Element;
+type PositionerProps$3 = Pick<Menu.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor" | "collisionBoundary" | "collisionPadding" | "collisionAvoidance" | "sticky" | "positionMethod">;
+interface DropdownMenuContentProps extends Menu.Popup.Props, PositionerProps$3 {
+  /** Keep the menu mounted in the DOM while hidden. */
+  keepMounted?: boolean;
+  /** Where to portal the menu; defaults to `<body>`. */
+  container?: Menu.Portal.Props["container"];
+}
+declare function DropdownMenuContent({ className, side, align, sideOffset, alignOffset, anchor, collisionBoundary, collisionPadding, collisionAvoidance, sticky, positionMethod, keepMounted, container, ...props }: DropdownMenuContentProps): React$1.JSX.Element;
+declare function DropdownMenuSubContent({ className, side, align, sideOffset, alignOffset, anchor, collisionBoundary, collisionPadding, collisionAvoidance, sticky, positionMethod, keepMounted, container, ...props }: DropdownMenuContentProps): React$1.JSX.Element;
+interface DropdownMenuItemProps extends Menu.Item.Props {
+  inset?: boolean;
+  variant?: "default" | "destructive";
+}
+declare function DropdownMenuItem({ className, inset, variant, ...props }: DropdownMenuItemProps): React$1.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, ...props }: Menu.CheckboxItem.Props): React$1.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: Menu.RadioItem.Props): React$1.JSX.Element;
+interface DropdownMenuLabelProps extends Menu.GroupLabel.Props {
+  inset?: boolean;
+}
+declare function DropdownMenuLabel({ className, inset, ...props }: DropdownMenuLabelProps): React$1.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: Menu.Separator.Props): React$1.JSX.Element;
+interface DropdownMenuSubTriggerProps extends Menu.SubmenuTrigger.Props {
+  inset?: boolean;
+}
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: DropdownMenuSubTriggerProps): React$1.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+//#endregion
+//#region src/components/dropzone.d.ts
+/** `1536` → `1.5 KB`, `0` → `0 B`; base 1024, one decimal above bytes. */
+declare function formatFileSize(bytes: number): string;
+interface DropzoneProps extends Omit<React$1.ComponentProps<"div">, "children" | "onDrop" | "onDragEnter" | "onDragOver" | "onDragLeave"> {
+  /** Called with the accepted files after a drop, a paste or the file dialog. */
+  onFiles: (files: File[]) => void;
+  /** Called with the rejected files and their reasons. */
+  onReject?: (rejections: FileRejection[]) => void;
+  /** MIME type to extension map, e.g. `{ "image/png": [".png"] }`. */
+  accept?: Accept;
+  /** Allow more than one file; defaults to true. */
+  multiple?: boolean;
+  /** Largest accepted file in bytes. */
+  maxSize?: number;
+  /** Most files accepted per drop; `0` means unlimited. */
+  maxFiles?: number;
+  disabled?: boolean;
+  /** Primary line of the default body. */
+  label?: React$1.ReactNode;
+  /** Muted second line of the default body; derived from `accept` and `maxSize` when omitted. */
+  hint?: React$1.ReactNode;
+  /** Replace the default body. A function receives react-dropzone's state. */
+  children?: React$1.ReactNode | ((state: DropzoneState) => React$1.ReactNode);
+}
+declare function Dropzone({ onFiles, onReject, accept, multiple, maxSize, maxFiles, disabled, label, hint, children, className, ref, ...props }: DropzoneProps): React$1.JSX.Element;
+interface FileListProps extends Omit<React$1.ComponentProps<"ul">, "children"> {
+  files: readonly File[];
+  /** Called with the file and its index when its remove button is pressed; the button is hidden when omitted. */
+  onRemove?: (file: File, index: number) => void;
+  /** Formats the size column; defaults to `formatFileSize`. */
+  formatSize?: (bytes: number) => string;
+}
+/**
+ * The files a Dropzone picked: name, size and a remove button per row. Rows
+ * are keyed by name, size and last-modified time so re-picking the same file
+ * keeps its row stable.
+ */
+declare function FileList({ files, onRemove, formatSize, className, ...props }: FileListProps): React$1.JSX.Element | null;
+//#endregion
+//#region src/components/empty-state.d.ts
+interface EmptyStateProps extends Omit<React$1.ComponentProps<"div">, "title"> {
+  /** A lucide icon; sized and coloured by the state. */
+  icon?: React$1.ReactNode;
+  title: React$1.ReactNode;
+  description?: React$1.ReactNode;
+  /** One or two buttons offering the next step. */
+  action?: React$1.ReactNode;
+  /** `compact` for an empty panel inside a card; `default` for an empty page. */
+  size?: "default" | "compact";
+}
+/**
+ * EmptyState — the centred, muted "nothing here yet" surface. The icon sits
+ * in a soft disc on the muted token; the title stays in the foreground so the
+ * eye lands on it, and everything else recedes.
+ */
+declare function EmptyState({ className, icon, title, description, action, size, children, ...props }: EmptyStateProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/error-banner.d.ts
+interface ErrorBannerProps extends Omit<React$1.ComponentProps<"div">, "children"> {
+  message: string;
+  onDismiss?: () => void;
+  onRetry?: () => void;
+}
+/**
+ * ErrorBanner — the one error surface every screen uses: a warning icon, the
+ * message, and optional Retry / Dismiss actions. Renders nothing for an empty
+ * message so callers can pass their error state straight through.
+ */
+declare function ErrorBanner({ message, onDismiss, onRetry, className, ...props }: ErrorBannerProps): React$1.JSX.Element | null;
+//#endregion
+//#region src/components/field.d.ts
+/**
+ * Field.
+ *
+ * The shadcn Field shape over Base UI's Field and Fieldset. `Field` is
+ * `Field.Root`: it owns the label/control/description/error association, so a
+ * `FieldLabel` focuses its `FieldControl` (or any Base UI control such as
+ * Checkbox, Select, Switch) without an explicit `htmlFor`, and every message
+ * ends up in the control's `aria-describedby`.
+ *
+ * Validity: Base UI puts `data-invalid` on every part once the control fails
+ * native constraints or a `validate` callback, and adds `aria-invalid` to the
+ * control. Pass `invalid` on `Field` when an external library owns the state
+ * (the Form component does this from react-hook-form).
+ *
+ * `FieldError` follows the field's validity: static children show once the
+ * control is invalid or the Field is marked `invalid`; `match="valueMissing"`
+ * narrows that to one constraint. Given `errors` (a react-hook-form error
+ * list) it renders whenever the list has a message.
+ */
+declare const fieldVariants: (props?: ({
+  orientation?: "horizontal" | "vertical" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface FieldProps extends React$1.ComponentProps<typeof Field$1.Root>, VariantProps<typeof fieldVariants> {}
+declare function Field({ className, orientation, invalid, ...props }: FieldProps): React$1.JSX.Element;
+/** Stacks a label and description beside a control in a horizontal Field. */
+declare function FieldContent({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+interface FieldLabelProps extends React$1.ComponentProps<typeof Field$1.Label> {}
+declare function FieldLabel({ className, ...props }: FieldLabelProps): React$1.JSX.Element;
+interface FieldControlProps extends React$1.ComponentProps<typeof Field$1.Control> {}
+/**
+ * The field's `<input>`, styled like Input. Swap the element with `render`
+ * (`render={<Textarea />}`); the input styling still applies unless the
+ * rendered element's own className wins in tailwind-merge.
+ */
+declare function FieldControl({ className, ...props }: FieldControlProps): React$1.JSX.Element;
+interface FieldDescriptionProps extends React$1.ComponentProps<typeof Field$1.Description> {}
+declare function FieldDescription({ className, ...props }: FieldDescriptionProps): React$1.JSX.Element;
+/** The shape react-hook-form gives for a field error; only `message` is read. */
+interface FieldErrorItem {
+  message?: string | undefined;
+}
+interface FieldErrorProps extends React$1.ComponentProps<typeof Field$1.Error> {
+  /**
+   * Errors from an external validator. Duplicate messages collapse; one message
+   * renders as text, several as a list.
+   */
+  errors?: ReadonlyArray<FieldErrorItem | undefined> | undefined;
+}
+declare function FieldError({ className, children, errors, match, ...props }: FieldErrorProps): React$1.JSX.Element | null;
+interface FieldsetProps extends React$1.ComponentProps<typeof Fieldset$1.Root> {}
+declare function Fieldset({ className, ...props }: FieldsetProps): React$1.JSX.Element;
+interface FieldsetLegendProps extends React$1.ComponentProps<typeof Fieldset$1.Legend> {}
+declare function FieldsetLegend({ className, ...props }: FieldsetLegendProps): React$1.JSX.Element;
+/** A vertical stack of Fields with the spacing a form uses between rows. */
+declare function FieldGroup({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+//#endregion
+//#region src/components/form.d.ts
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>({ children, watch, getValues, getErrors, getFieldState, setError, clearErrors, setValue, setValues, trigger, formState, resetField, reset, resetDefaultValues, handleSubmit, unregister, control, register, setFocus, subscribe }: import("react-hook-form").FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React$1.JSX.Element;
+declare function FormField<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TTransformedValues = TFieldValues>(props: ControllerProps<TFieldValues, TName, TTransformedValues>): React$1.JSX.Element;
+interface UseFormFieldReturn {
+  id: string;
+  name: string;
+  formItemId: string;
+  formDescriptionId: string;
+  formMessageId: string;
+  invalid: boolean;
+  isDirty: boolean;
+  isTouched: boolean;
+  isValidating: boolean;
+  error?: FieldError$1 | undefined;
+}
+declare function useFormField(): UseFormFieldReturn;
+interface FormItemProps extends Omit<FieldProps, "invalid" | "name"> {}
+declare function FormItem({ className, ...props }: FormItemProps): React$1.JSX.Element;
+interface FormLabelProps extends FieldLabelProps {}
+declare function FormLabel({ className, ...props }: FormLabelProps): React$1.JSX.Element;
+interface FormControlProps extends React$1.HTMLAttributes<HTMLElement> {
+  /** The single control element; it receives `id`, `aria-describedby` and `aria-invalid`. */
+  children: React$1.ReactElement;
+}
+declare function FormControl({ children, ...props }: FormControlProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+interface FormDescriptionProps extends FieldDescriptionProps {}
+declare function FormDescription({ className, ...props }: FormDescriptionProps): React$1.JSX.Element;
+interface FormMessageProps extends Omit<FieldErrorProps, "errors" | "match"> {}
+declare function FormMessage({ className, children, ...props }: FormMessageProps): React$1.JSX.Element | null;
+//#endregion
+//#region src/components/input.d.ts
+/**
+ * Input.
+ *
+ * A plain `<input>`; Base UI has no primitive for it and none is needed. The
+ * look is cortenaweb's: sunken surface, subtle border that strengthens on hover
+ * and takes the ring colour on focus. `aria-invalid` swaps the border and ring
+ * for the destructive pair so a Field can mark errors without extra classes.
+ */
+declare const inputClassName: string;
+interface InputProps extends React$1.ComponentProps<"input"> {}
+declare function Input({ className, type, ...props }: InputProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/kbd.d.ts
+/**
+ * Kbd — an inline keyboard-key cap. Mono caption-sm text on the sunken
+ * surface, with a heavier bottom border for the key-cap read.
+ */
+declare function Kbd({ className, ...props }: React$1.ComponentProps<"kbd">): React$1.JSX.Element;
+//#endregion
+//#region src/components/label.d.ts
+/**
+ * Label — a plain `<label>`. Base UI's Label lives inside Field, so this is
+ * the standalone form caption for anything that is not a Field.
+ */
+declare const labelVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+interface LabelProps extends React$1.ComponentProps<"label">, VariantProps<typeof labelVariants> {}
+declare function Label({ className, ...props }: LabelProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/loading-skeleton.d.ts
+type LoadingSkeletonPreset = "list" | "table" | "card" | "form";
+interface LoadingSkeletonProps extends React$1.ComponentProps<"div"> {
+  /** Which shape of content is loading. */
+  preset?: LoadingSkeletonPreset;
+  /** Rows (list, table, form) or cards. Each preset has a sensible default. */
+  rows?: number;
+  /** Columns for `table` and `card`. */
+  columns?: number;
+}
+/**
+ * LoadingSkeleton — page-level placeholders assembled from Skeleton, one per
+ * shape of content: a list of rows with an avatar, a table with a header row,
+ * a grid of cards, or a stacked form. Announces itself as busy so assistive
+ * technology knows the region is loading; the blocks themselves are hidden.
+ */
+declare function LoadingSkeleton({ className, preset, rows, columns, ...props }: LoadingSkeletonProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/markdown.d.ts
+/** The GitHub schema, plus `class="language-*"` on code and `checked` on task boxes. */
+declare const markdownSanitizeSchema: Options$1;
+interface CodeRendererProps {
+  /** The fenced block's text, without a trailing newline. */
+  code: string;
+  /** From the fence's info string, e.g. `ts` for ```ts. */
+  language: string | undefined;
+}
+interface MarkdownProps extends Omit<React$1.ComponentProps<"div">, "children"> {
+  /** The markdown source. */
+  children: string | null | undefined;
+  /** Tighter rhythm and smaller headings, for chat bubbles. */
+  compact?: boolean;
+  /** Renders fenced code blocks; the copy button is still added. Use for syntax highlighting. */
+  codeRenderer?: (props: CodeRendererProps) => React$1.ReactNode;
+  /** Override or extend the element map. */
+  components?: Components;
+  /** Extra remark plugins, appended after GFM. */
+  remarkPlugins?: NonNullable<Options["remarkPlugins"]>;
+  /** Extra rehype plugins, appended after sanitize. */
+  rehypePlugins?: NonNullable<Options["rehypePlugins"]>;
+  /** Replace the sanitize schema; defaults to `markdownSanitizeSchema`. */
+  sanitizeSchema?: Options$1;
+  /** Rewrite URLs; defaults to react-markdown's, which drops non-http(s)/mailto/tel schemes. */
+  urlTransform?: Options["urlTransform"];
+}
+declare function Markdown({ children, compact, codeRenderer, components, remarkPlugins, rehypePlugins, sanitizeSchema, urlTransform, className, ...props }: MarkdownProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/page-header.d.ts
+interface PageHeaderProps extends Omit<React$1.ComponentProps<"header">, "title"> {
+  /** The page title. Rendered as the h1; use `titleAs` to demote it. */
+  title: React$1.ReactNode;
+  description?: React$1.ReactNode;
+  /** Buttons for the page, right-aligned on wide viewports. */
+  actions?: React$1.ReactNode;
+  /** Short uppercase label above the title, e.g. a section or product name. */
+  eyebrow?: React$1.ReactNode;
+  /** A Breadcrumb or any navigation rendered above the eyebrow. */
+  breadcrumb?: React$1.ReactNode;
+  /** Heading level when the page already has an h1. */
+  titleAs?: "h1" | "h2" | "h3";
+}
+/**
+ * PageHeader — the top of every screen: breadcrumb, eyebrow, title,
+ * description, and an actions slot. The title is an h1 on the h2 step of the
+ * type scale in the display face, so screens read as one product rather than
+ * as a stack of card titles.
+ */
+declare function PageHeader({ className, title, description, actions, eyebrow, breadcrumb, titleAs: Title, children, ...props }: PageHeaderProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/popover.d.ts
+/**
+ * Popover.
+ *
+ * `PopoverContent` composes Base UI's Portal + Positioner + Popup so consumers
+ * keep writing `<PopoverContent side="bottom" align="start">`; the positioning
+ * props are forwarded to the Positioner, which is where Base UI reads them.
+ *
+ * Radix users: `asChild` on the trigger becomes `render={<Button />}`;
+ * `PopoverAnchor` is gone — pass `anchor={ref}` to `PopoverContent` instead.
+ */
+declare function Popover(props: Popover$1.Root.Props): import("react").JSX.Element;
+declare function PopoverTrigger(props: Popover$1.Trigger.Props): import("react").JSX.Element;
+declare function PopoverClose(props: Popover$1.Close.Props): import("react").JSX.Element;
+declare function PopoverTitle({ className, ...props }: Popover$1.Title.Props): import("react").JSX.Element;
+declare function PopoverDescription({ className, ...props }: Popover$1.Description.Props): import("react").JSX.Element;
+type PositionerProps$2 = Pick<Popover$1.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor" | "collisionBoundary" | "collisionPadding" | "collisionAvoidance" | "sticky" | "positionMethod">;
+interface PopoverContentProps extends Popover$1.Popup.Props, PositionerProps$2 {
+  /** Keep the popup mounted in the DOM while hidden. */
+  keepMounted?: boolean;
+  /** Where to portal the popup; defaults to `<body>`. */
+  container?: Popover$1.Portal.Props["container"];
+}
+declare function PopoverContent({ className, side, align, sideOffset, alignOffset, anchor, collisionBoundary, collisionPadding, collisionAvoidance, sticky, positionMethod, keepMounted, container, ...props }: PopoverContentProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/progress.d.ts
+/**
+ * Progress.
+ *
+ * `Progress` renders the Base UI root (a `<div role="progressbar">` carrying
+ * `aria-valuenow`) with the track and indicator already inside; Base UI sizes
+ * the indicator to `value` as a percentage of `min`..`max`. Put a
+ * `ProgressLabel` and `ProgressValue` in `children` for a captioned bar; they
+ * render in a row above the track. `value={null}` gives an indeterminate bar.
+ */
+interface ProgressProps extends React$1.ComponentProps<typeof Progress$1.Root> {}
+declare function Progress({ className, children, ...props }: ProgressProps): React$1.JSX.Element;
+declare function ProgressTrack({ className, ...props }: React$1.ComponentProps<typeof Progress$1.Track>): React$1.JSX.Element;
+declare function ProgressIndicator({ className, ...props }: React$1.ComponentProps<typeof Progress$1.Indicator>): React$1.JSX.Element;
+declare function ProgressLabel({ className, ...props }: React$1.ComponentProps<typeof Progress$1.Label>): React$1.JSX.Element;
+declare function ProgressValue({ className, ...props }: React$1.ComponentProps<typeof Progress$1.Value>): React$1.JSX.Element;
+//#endregion
+//#region src/components/radio-group.d.ts
+/**
+ * Radio group.
+ *
+ * `RadioGroup` owns the value (`value` / `defaultValue` / `onValueChange`) and
+ * renders a `<div role="radiogroup">`; each `RadioGroupItem` is a Base UI
+ * `Radio.Root` (`<span role="radio">`) with a dot indicator that only mounts
+ * while checked. Arrow keys move the selection, as the ARIA pattern requires.
+ */
+interface RadioGroupProps extends React$1.ComponentProps<typeof RadioGroup$1> {}
+declare function RadioGroup({ className, ...props }: RadioGroupProps): React$1.JSX.Element;
+interface RadioGroupItemProps extends React$1.ComponentProps<typeof Radio.Root> {}
+declare function RadioGroupItem({ className, ...props }: RadioGroupItemProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/scroll-area.d.ts
+/**
+ * ScrollArea.
+ *
+ * Base UI positions the scrollbar and thumb itself (absolute inside the root,
+ * thumb size in `--scroll-area-thumb-*`); this file only sets the track width,
+ * the thumb colour and the hover/scroll reveal. Base UI also unmounts the
+ * scrollbar when there is nothing to scroll, so an empty list shows no track.
+ *
+ * Radix users: the `display: table` wrapper is gone, so `truncate` works
+ * inside the viewport without the `[&>div]:!block` override cortenaweb needed.
+ * `type="always" | "hover"` is gone too; the scrollbar shows on hover and while
+ * scrolling, and `keepMounted` on `ScrollBar` keeps it in the DOM otherwise.
+ */
+interface ScrollAreaProps extends ScrollArea$1.Root.Props {
+  /** Which scrollbars to render. Defaults to vertical only. */
+  orientation?: "vertical" | "horizontal" | "both";
+}
+declare function ScrollArea({ className, children, orientation, ...props }: ScrollAreaProps): import("react").JSX.Element;
+declare function ScrollBar({ className, orientation, ...props }: ScrollArea$1.Scrollbar.Props): import("react").JSX.Element;
+//#endregion
+//#region src/components/section-card.d.ts
+interface SectionCardProps extends Omit<CardProps, "title"> {
+  title: React$1.ReactNode;
+  description?: React$1.ReactNode;
+  /** Controls for the section, right-aligned in the header row. */
+  actions?: React$1.ReactNode;
+  /** Rendered in a CardFooter under the body. */
+  footer?: React$1.ReactNode;
+  /** Remove the body padding, for a table or list that fills the card. */
+  flush?: boolean;
+  /** Class on the body wrapper. */
+  bodyClassName?: string;
+}
+/**
+ * SectionCard — a Card with a header row (title, description, actions), a
+ * body and an optional footer. It composes the Card parts rather than
+ * restyling them, so a SectionCard and a hand-built Card look identical.
+ */
+declare function SectionCard({ title, description, actions, footer, flush, bodyClassName, children, ...props }: SectionCardProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/segmented.d.ts
+/**
+ * Segmented control.
+ *
+ * A single-select row of options exposed as a radiogroup: the same semantics
+ * cortenaweb shipped, which screen readers announce as "1 of 3, selected".
+ * The active segment lifts onto the raised surface with the small shadow; the
+ * others read as muted text until hovered.
+ */
+interface SegmentedOption<T extends string = string> {
+  value: T;
+  label: React$1.ReactNode;
+  icon?: React$1.ReactNode;
+  disabled?: boolean;
+}
+interface SegmentedProps<T extends string = string> extends Omit<React$1.ComponentProps<"div">, "onChange"> {
+  value: T;
+  onValueChange: (value: T) => void;
+  options: readonly SegmentedOption<T>[];
+  "aria-label"?: string;
+}
+declare function Segmented<T extends string = string>({ className, value, onValueChange, options, "aria-label": ariaLabel, ...props }: SegmentedProps<T>): React$1.JSX.Element;
+//#endregion
+//#region src/components/select.d.ts
+/**
+ * Select.
+ *
+ * `SelectContent` composes Base UI's Portal + Positioner + Popup so consumers
+ * keep writing `<SelectContent side="bottom" align="start">`; positioning
+ * props are forwarded to the Positioner, which is where Base UI reads them.
+ *
+ * Radix users:
+ * - `SelectValue` shows the raw value unless the Root is given `items`
+ *   (`{ [value]: label }` or `[{ value, label }]`) or `itemToStringLabel`;
+ *   Base UI does not read the label out of an unmounted `SelectItem`.
+ * - `onValueChange` receives `(value, eventDetails)`.
+ * - `SelectContent` defaults to the dropdown layout; pass
+ *   `alignItemWithTrigger` for Base UI's native-like overlay of the selected item.
+ */
+declare function Select<Value, Multiple extends boolean | undefined = false>(props: Select$1.Root.Props<Value, Multiple>): import("react").JSX.Element;
+declare function SelectGroup({ className, ...props }: Select$1.Group.Props): import("react").JSX.Element;
+declare function SelectValue({ className, ...props }: Select$1.Value.Props): import("react").JSX.Element;
+interface SelectTriggerProps extends Select$1.Trigger.Props {
+  size?: "sm" | "md";
+}
+declare function SelectTrigger({ className, size, children, ...props }: SelectTriggerProps): import("react").JSX.Element;
+type PositionerProps$1 = Pick<Select$1.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor" | "collisionBoundary" | "collisionPadding" | "collisionAvoidance" | "sticky" | "positionMethod" | "alignItemWithTrigger">;
+interface SelectContentProps extends Select$1.Popup.Props, PositionerProps$1 {
+  /** Where to portal the popup; defaults to `<body>`. */
+  container?: Select$1.Portal.Props["container"];
+}
+declare function SelectContent({ className, children, side, align, sideOffset, alignOffset, anchor, collisionBoundary, collisionPadding, collisionAvoidance, sticky, positionMethod, alignItemWithTrigger, container, ...props }: SelectContentProps): import("react").JSX.Element;
+declare function SelectLabel({ className, ...props }: Select$1.GroupLabel.Props): import("react").JSX.Element;
+declare function SelectItem({ className, children, ...props }: Select$1.Item.Props): import("react").JSX.Element;
+declare function SelectSeparator({ className, ...props }: Select$1.Separator.Props): import("react").JSX.Element;
+//#endregion
+//#region src/components/separator.d.ts
+interface SeparatorProps extends React$1.ComponentProps<typeof Separator$1> {
+  /**
+   * Purely visual: renders with `role="none"` so screen readers skip it.
+   * Defaults to true, matching the Radix component this replaces.
+   */
+  decorative?: boolean;
+}
+/**
+ * Separator — a one-pixel rule on the border token. Base UI supplies the
+ * `role="separator"` and `aria-orientation` semantics when not decorative.
+ */
+declare function Separator({ className, orientation, decorative, ...props }: SeparatorProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/sheet.d.ts
+/**
+ * Sheet: a Dialog whose Popup is anchored to one edge of the viewport.
+ *
+ * Same Base UI parts as Dialog (Root, Trigger, Portal, Backdrop, Popup, Title,
+ * Description, Close); only the Popup's placement differs, chosen by `side`.
+ * `SheetContent` composes Portal + Backdrop + Popup so consumers keep writing
+ * `<SheetContent side="right">…</SheetContent>`.
+ */
+declare function Sheet(props: Dialog$1.Root.Props): React$1.JSX.Element;
+declare function SheetTrigger(props: Dialog$1.Trigger.Props): React$1.JSX.Element;
+declare function SheetClose(props: Dialog$1.Close.Props): React$1.JSX.Element;
+declare function SheetPortal(props: Dialog$1.Portal.Props): React$1.JSX.Element;
+declare function SheetOverlay({ className, ...props }: Dialog$1.Backdrop.Props): React$1.JSX.Element;
+declare const sheetVariants: (props?: ({
+  side?: "top" | "bottom" | "left" | "right" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface SheetContentProps extends Dialog$1.Popup.Props, VariantProps<typeof sheetVariants> {
+  /** Keep the sheet mounted in the DOM while hidden. */
+  keepMounted?: boolean;
+  /** Where to portal the sheet; defaults to `<body>`. */
+  container?: Dialog$1.Portal.Props["container"];
+}
+declare function SheetContent({ side, className, children, keepMounted, container, ...props }: SheetContentProps): React$1.JSX.Element;
+declare function SheetHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function SheetFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function SheetTitle({ className, ...props }: Dialog$1.Title.Props): React$1.JSX.Element;
+declare function SheetDescription({ className, ...props }: Dialog$1.Description.Props): React$1.JSX.Element;
+//#endregion
+//#region src/components/skeleton.d.ts
+/**
+ * Skeleton — a pulsing placeholder block. Sized by the consumer (`h-4 w-40`);
+ * the fill is the border token, which reads on the canvas, a card and a
+ * popover in both themes.
+ */
+declare function Skeleton({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+//#endregion
+//#region src/components/sortable-list.d.ts
+/**
+ * SortableList.
+ *
+ * A reorderable list over dnd-kit: `DndContext` + `SortableContext` around one
+ * `useSortable` item per entry. The list owns nothing — it calls `onReorder`
+ * with the next array and the consumer stores it. Pointer and keyboard sensors
+ * are wired (Space picks up, arrows move, Space drops, Escape cancels) and a
+ * `DragOverlay` paints the lifted copy with `--ds-shadow-lg` while the item
+ * left behind dims and takes the ring colour.
+ *
+ * By default the whole row is the drag activator. Pass `handle` to restrict
+ * dragging to a `<SortableHandle>` (or any element given `handleProps`) so
+ * buttons and inputs inside a row stay clickable.
+ */
+/** Spread onto the element that should start a drag. */
+interface SortableHandleProps extends Partial<DraggableAttributes> {
+  ref: (element: HTMLElement | null) => void;
+  onKeyDown?: React$1.KeyboardEventHandler<HTMLElement>;
+  onPointerDown?: React$1.PointerEventHandler<HTMLElement>;
+  onMouseDown?: React$1.MouseEventHandler<HTMLElement>;
+  onTouchStart?: React$1.TouchEventHandler<HTMLElement>;
+}
+interface SortableRenderState {
+  /** Attributes, listeners and ref for a custom drag handle. */
+  handleProps: SortableHandleProps;
+  /** True for the item being dragged (and for the overlay copy). */
+  isDragging: boolean;
+}
+interface SortableListProps<T> extends Omit<React$1.ComponentProps<"ul">, "children"> {
+  items: readonly T[];
+  /** Stable id per item; must be unique within the list. */
+  getId: (item: T) => UniqueIdentifier;
+  /** Called with the reordered array after a successful drop. */
+  onReorder: (next: T[]) => void;
+  renderItem: (item: T, state: SortableRenderState) => React$1.ReactNode;
+  /** Layout axis; also selects the sorting strategy. */
+  orientation?: "vertical" | "horizontal";
+  /** Only a `<SortableHandle>` (or an element given `handleProps`) starts a drag. */
+  handle?: boolean;
+  /** Disables every sensor and hides the handles. */
+  disabled?: boolean;
+  /** Class name for each item wrapper. */
+  itemClassName?: string;
+}
+/**
+ * A grip button that starts the drag for its row. Reads the row's activator
+ * props from context, so it needs no wiring beyond being rendered inside
+ * `renderItem`. Hidden (kept in layout) when the list is disabled.
+ */
+declare function SortableHandle({ className, children, ...props }: React$1.ComponentProps<"button">): React$1.JSX.Element;
+declare function SortableList<T>({ items, getId, onReorder, renderItem, orientation, handle, disabled, itemClassName: itemClass, className, ...props }: SortableListProps<T>): React$1.JSX.Element;
+//#endregion
+//#region src/components/spinner.d.ts
+interface SpinnerProps extends React$1.ComponentProps<"span"> {
+  /** Diameter in px. Defaults to 16. */
+  size?: number;
+}
+/**
+ * Spinner — a ring with a primary-coloured leading edge. Announces itself as
+ * `role="status"` with a "Loading" label; pass `aria-label` to override.
+ */
+declare function Spinner({ className, size, style, ...props }: SpinnerProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/status-dot.d.ts
+type StatusDotTone = "accent" | "success" | "warning" | "danger" | "info" | "neutral";
+interface StatusDotProps extends Omit<React$1.ComponentProps<"span">, "children"> {
+  tone?: StatusDotTone;
+  /** Adds a pinging halo behind the dot for "currently active" states. */
+  live?: boolean;
+  label?: React$1.ReactNode;
+  /** Dot diameter in px. Defaults to 7. */
+  size?: number;
+}
+/**
+ * StatusDot — a coloured dot with an optional caption. `live` layers a ping
+ * ring in the same tone behind the dot.
+ */
+declare function StatusDot({ className, tone, live, label, size, style, ...props }: StatusDotProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/switch.d.ts
+/**
+ * Switch.
+ *
+ * Base UI renders a `<span role="switch">` with a hidden `<input>` beside it,
+ * so the control submits with forms and takes `checked`/`defaultChecked`
+ * exactly like a checkbox. State is exposed as `data-checked` /
+ * `data-unchecked` / `data-disabled`, which is what the classes key on.
+ *
+ * cortenaweb users: `checked` and `onCheckedChange` keep their names, but the
+ * control is now uncontrolled by default; pass `defaultChecked` if you do not
+ * hold the state yourself.
+ */
+interface SwitchProps extends React$1.ComponentProps<typeof Switch$1.Root> {}
+declare function Switch({ className, ...props }: SwitchProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/tabs.d.ts
+/**
+ * Tabs — the underlined pattern (primary-coloured underline under the active
+ * tab). For the inset segmented style use Segmented.
+ *
+ * The underline is a Base UI `Tabs.Indicator` rendered inside `TabsList`, so it
+ * slides between tabs instead of snapping. Base UI exposes the active tab's
+ * box as `--active-tab-left` / `--active-tab-width` on the indicator.
+ *
+ * Radix users: `data-state="active"` is now `data-active`; `TabsTrigger` and
+ * `TabsContent` are Base UI's `Tab` and `Panel` under the shadcn names. Arrow
+ * keys activate as they move (Radix's `activationMode="automatic"`); pass
+ * `activateOnFocus={false}` on `TabsList` for manual activation.
+ */
+declare function Tabs({ className, ...props }: Tabs$1.Root.Props): import("react").JSX.Element;
+declare function TabsList({ className, children, activateOnFocus, ...props }: Tabs$1.List.Props): import("react").JSX.Element;
+declare function TabsIndicator({ className, ...props }: Tabs$1.Indicator.Props): import("react").JSX.Element;
+declare function TabsTrigger({ className, ...props }: Tabs$1.Tab.Props): import("react").JSX.Element;
+declare function TabsContent({ className, ...props }: Tabs$1.Panel.Props): import("react").JSX.Element;
+//#endregion
+//#region src/components/textarea.d.ts
+/**
+ * Textarea.
+ *
+ * Same surface, border, focus ring and invalid state as Input so the two sit
+ * together in a form. `autoGrow` resizes the element to its content on every
+ * change (and on mount), which is how chat composers and note fields use it.
+ */
+declare const textareaClassName: string;
+interface TextareaProps extends React$1.ComponentProps<"textarea"> {
+  /** When true the textarea grows to fit its content instead of scrolling. */
+  autoGrow?: boolean;
+}
+declare function Textarea({ className, autoGrow, onChange, ref, ...props }: TextareaProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/toast.d.ts
+/**
+ * Toast.
+ *
+ * Base UI toasts are imperative: `useToast().add({ title, description, type })`
+ * from anywhere under the provider. `Toaster` mounts `Toast.Provider` and the
+ * `Toast.Viewport`, and renders every toast the manager holds, so it must wrap
+ * the part of the tree that calls `useToast` (usually the whole app).
+ *
+ * The `type` field on a toast picks the variant: `default`, `success`,
+ * `warning` or `destructive`, painted from the semantic soft tokens. Anything
+ * else falls back to `default`.
+ *
+ * sonner / Radix users: there is no `toast()` module singleton. Get the manager
+ * from `useToast()` inside a component, or build one with
+ * `createToastManager()` from `@base-ui/react/toast` and pass it as
+ * `toastManager` to `Toaster` when you need to fire toasts outside React.
+ */
+declare const toastVariants: (props?: ({
+  variant?: "destructive" | "default" | "success" | "warning" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/** The Base UI toast manager: `{ toasts, add, close, update, promise }`. */
+declare const useToast: typeof Toast$1.useToastManager;
+interface ToastProps extends Omit<Toast$1.Root.Props, "toast">, VariantProps<typeof toastVariants> {
+  toast: Toast$1.Root.ToastObject;
+}
+/** One toast. Rendered by `Toaster`; exported for custom viewports. */
+declare function Toast({ className, variant, toast, ...props }: ToastProps): React$1.JSX.Element;
+interface ToasterProps extends Toast$1.Provider.Props {
+  /** Corner of the screen the stack grows from. */
+  position?: "bottom-right" | "bottom-left" | "top-right" | "top-left";
+  /** Extra classes on the viewport. */
+  className?: string;
+  children?: React$1.ReactNode;
+}
+/**
+ * Provider + viewport. Wrap the app in it once; `useToast()` works anywhere
+ * beneath. Toasts render in a fixed corner as a flat stack (newest last).
+ */
+declare function Toaster({ position, className, children, ...props }: ToasterProps): React$1.JSX.Element;
+//#endregion
+//#region src/components/toolbar.d.ts
+interface ToolbarProps extends React$1.ComponentProps<"div"> {
+  /** Draw a rule under the row, for a toolbar that sits above a table or list. */
+  bordered?: boolean;
+}
+/**
+ * Toolbar — a single flex row of controls above content. `ToolbarStart` and
+ * `ToolbarEnd` group the two ends; `ToolbarSeparator` is a short vertical rule
+ * between clusters of controls in the same group.
+ */
+declare function Toolbar({ className, bordered, ...props }: ToolbarProps): React$1.JSX.Element;
+declare function ToolbarStart({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ToolbarEnd({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ToolbarSeparator({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+//#endregion
+//#region src/components/tooltip.d.ts
+/**
+ * Tooltip.
+ *
+ * Base UI's Tooltip opens on hover and focus (never on click). Radix users:
+ * `asChild` on the trigger becomes `render={<Button />}`, and the delay moves
+ * from `delayDuration` on the Provider to `delay` on the Provider or Trigger.
+ * `TooltipContent` composes Portal + Positioner + Popup so the consumer still
+ * writes one element; `side`, `align` and `sideOffset` are forwarded to the
+ * Positioner where Base UI expects them. Base UI sets no ARIA role on the
+ * popup; `role="tooltip"` is added here so it reads like the Radix version.
+ */
+declare function TooltipProvider(props: Tooltip$2.Provider.Props): import("react").JSX.Element;
+declare function Tooltip(props: Tooltip$2.Root.Props): import("react").JSX.Element;
+declare function TooltipTrigger(props: Tooltip$2.Trigger.Props): import("react").JSX.Element;
+type PositionerProps = Pick<Tooltip$2.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor" | "collisionBoundary" | "collisionPadding" | "collisionAvoidance" | "sticky" | "positionMethod">;
+interface TooltipContentProps extends Tooltip$2.Popup.Props, PositionerProps {
+  /** Keep the popup mounted in the DOM while hidden. */
+  keepMounted?: boolean;
+  /** Where to portal the popup; defaults to `<body>`. */
+  container?: Tooltip$2.Portal.Props["container"];
+}
+declare function TooltipContent({ className, side, align, sideOffset, alignOffset, anchor, collisionBoundary, collisionPadding, collisionAvoidance, sticky, positionMethod, keepMounted, container, ...props }: TooltipContentProps): import("react").JSX.Element;
+//#endregion
+//#region src/hooks/use-cortena-theme.d.ts
+/**
+ * useCortenaTheme — the one theme bridge for every Cortena surface.
+ *
+ * cortena-design drives dark mode off `data-theme="light" | "dark"` on <html>
+ * and falls back to `prefers-color-scheme` when the attribute is absent. So the
+ * hook has exactly three jobs, consolidated from the flux and engram copies:
+ *
+ *  1. Remember the last choice in localStorage and put it back before the
+ *     first paint (`applyStoredTheme`, or `themeInitScript` as a blocking
+ *     <script> for apps that cannot run a module that early).
+ *  2. Listen for the message cortenaweb posts into an extension iframe on load
+ *     and on every theme change:
+ *
+ *         iframe.contentWindow.postMessage({ type: "cortena-theme", colors }, "*")
+ *
+ *     and apply the *mode* it implies. The host may say `mode` or `theme`
+ *     explicitly; otherwise the background colour's luminance decides.
+ *  3. Expose `{ theme, resolvedTheme, setTheme }` so a settings toggle can
+ *     drive the same state.
+ *
+ * What it deliberately does NOT do is apply the individual colours in the
+ * host's message. The palette comes from cortena-design tokens, the single
+ * source of truth; writing the host's raw values onto `--ds-*` or `--color-*`
+ * would silently override every token the design system publishes. The
+ * `colors` object is read for its luminance only, never written to the DOM.
+ */
+type CortenaTheme = "light" | "dark" | "system";
+type ResolvedCortenaTheme = "light" | "dark";
+/** The message cortenaweb posts into an embedded iframe. */
+interface CortenaThemeMessage {
+  type: "cortena-theme";
+  /** Explicit mode. Preferred when present. */
+  theme?: CortenaTheme;
+  /** Older name for `theme`, sent by some hosts. */
+  mode?: CortenaTheme;
+  /** Raw palette. Only `background` is read, and only to infer the mode. */
+  colors?: Record<string, unknown>;
+}
+interface UseCortenaThemeOptions {
+  /** localStorage key the choice persists under. Defaults to `"cortena.theme"`. */
+  storageKey?: string;
+  /**
+   * Origins allowed to push a theme via postMessage. When omitted or empty,
+   * every origin is accepted — matching cortenaweb, which posts with `"*"`
+   * to cross-origin extensions. A same-origin embed should pass
+   * `[window.location.origin]`.
+   */
+  allowedOrigins?: readonly string[];
+  /** Set false to keep the state and DOM sync but ignore host messages. */
+  listen?: boolean;
+}
+interface UseCortenaThemeResult {
+  /** The stored choice; `"system"` when nothing has been chosen. */
+  theme: CortenaTheme;
+  /** What is actually painted: `theme`, or the OS scheme when `theme` is `"system"`. */
+  resolvedTheme: ResolvedCortenaTheme;
+  setTheme: (theme: CortenaTheme) => void;
+}
+export declare const DEFAULT_THEME_STORAGE_KEY = "cortena.theme";
+export declare const THEME_MESSAGE_TYPE = "cortena-theme";
+/**
+ * Write the mode onto <html>. `"system"` removes the attribute so
+ * cortena-design's `:root:not([data-theme])` fallback follows the OS.
+ */
+export declare function applyTheme(theme: CortenaTheme, root?: HTMLElement): void;
+export declare function readStoredTheme(storageKey?: string): CortenaTheme;
+/**
+ * Put the remembered mode back on <html>. Tiny and synchronous on purpose:
+ * call it at the top of the app entry, before `createRoot`, so a reload does
+ * not flash the light palette at somebody reading in the dark. Returns what
+ * it applied.
+ */
+export declare function applyStoredTheme(storageKey?: string): CortenaTheme;
+/**
+ * The same logic as `applyStoredTheme` as a self-contained IIFE string, for
+ * consumers that inject a blocking `<script>` into <head> (Next.js
+ * `dangerouslySetInnerHTML`, or a Vite index.html). It cannot import anything,
+ * which is why it is duplicated rather than derived.
+ */
+export declare function getThemeInitScript(storageKey?: string): string;
+/** `getThemeInitScript()` for the default storage key. */
+export declare const themeInitScript: string;
+/**
+ * Infer the mode from a hex background colour by relative luminance. Any
+ * other colour syntax is ignored, since the host only ever sends hex and a
+ * wrong guess is worse than no change.
+ */
+export declare function themeFromBackground(background: unknown): ResolvedCortenaTheme | null;
+/**
+ * The mode a host message asks for, or null when it does not carry one.
+ * Explicit `theme` / `mode` win; otherwise the background luminance decides.
+ */
+export declare function themeFromMessage(data: unknown): CortenaTheme | null;
+export declare function useCortenaTheme(options?: UseCortenaThemeOptions): UseCortenaThemeResult;
 //#endregion
-export { Button, type ButtonProps, buttonVariants };
+export { type Accept, Accordion, AccordionContent, AccordionItem, AccordionTrigger, Alert, AlertDescription, AlertIcon, type AlertProps, AlertTitle, Area, AreaChart, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, Bar, BarChart, Button, type ButtonProps, Calendar, CalendarDayButton, type CalendarProps, Card, CardContent, CardDescription, CardFooter, CardHeader, type CardProps, CardTitle, CartesianGrid, Cell, Chart, type ChartConfig, ChartContainer, type ChartContainerProps, type ChartDataFor, type ChartDay, ChartEmpty, type ChartEngine, ChartError, ChartLegend, ChartLegendContent, type ChartLegendContentProps, ChartLoading, type ChartPoint, type ChartProps, type ChartRenderer, type ChartRow, type ChartScale, type ChartScales, type ChartSeries, type ChartSlice, ChartTooltip, ChartTooltipContent, type ChartTooltipContentProps, type ChartTree, type ChartType, Checkbox, type CheckboxProps, Chip, type ChipProps, type ClientSource, type CodeRendererProps, Combobox, ComboboxChip, type ComboboxChipProps, ComboboxChips, type ComboboxChipsProps, ComboboxClear, ComboboxCollection, ComboboxContent, type ComboboxContentProps, ComboboxEmpty, ComboboxGroup, ComboboxGroupLabel, ComboboxInput, type ComboboxInputProps, ComboboxItem, ComboboxSeparator, ComboboxStatus, ComboboxTrigger, ComboboxValue, Command, CommandDialog, type CommandDialogProps, CommandEmpty, CommandGroup, CommandInput, CommandItem, type CommandItemProps, CommandList, CommandLoading, CommandSeparator, CommandShortcut, ComposedChart, type CortenaTheme, type CortenaThemeMessage, type DataSource, DataTable, type DataTableCell, type DataTableColumn, type DataTableColumnDef, DataTableColumnHeader, type DataTableColumnHeaderProps, type DataTableColumnMeta, type DataTableEditable, type DataTableEditingCell, DataTableExportMenu, type DataTableExportMenuProps, DataTableFacetedFilter, type DataTableFacetedFilterOption, type DataTableFacetedFilterProps, type DataTableFeatures, type DataTableInstance, DataTablePagination, type DataTablePaginationMode, type DataTablePaginationProps, type DataTableProps, type DataTableRow, type DataTableState, type DataTableTable, DataTableToolbar, type DataTableToolbarProps, DataTableView, DataTableViewOptions, type DataTableViewOptionsProps, type DataTableViewProps, DateField, type DateFieldProps, DatePicker, type DatePickerProps, DateRangePicker, type DateRangePickerProps, Dialog, DialogBody, DialogClose, DialogContent, type DialogContentProps, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, Dropzone, type DropzoneProps, type DropzoneState, EmptyState, type EmptyStateProps, ErrorBanner, type ErrorBannerProps, type ExportCell, type ExportSheet, Field, FieldContent, FieldControl, type FieldControlProps, FieldDescription, type FieldDescriptionProps, FieldError, type FieldErrorItem, type FieldErrorProps, FieldGroup, FieldLabel, type FieldLabelProps, type FieldProps, Fieldset, FieldsetLegend, type FieldsetLegendProps, type FieldsetProps, FileList, type FileListProps, type FileRejection, Form, FormControl, type FormControlProps, FormDescription, type FormDescriptionProps, FormField, FormItem, type FormItemProps, FormLabel, type FormLabelProps, FormMessage, type FormMessageProps, Funnel, FunnelChart, Input, type InputProps, Kbd, Label, LabelList, type LabelProps, Line, LineChart, LoadingSkeleton, type LoadingSkeletonPreset, type LoadingSkeletonProps, Markdown, type Components as MarkdownComponents, type MarkdownProps, type NivoTheme, PageHeader, type PageHeaderProps, Pie, PieChart, PolarAngleAxis, PolarGrid, PolarRadiusAxis, Popover, PopoverClose, PopoverContent, type PopoverContentProps, PopoverDescription, PopoverTitle, PopoverTrigger, Progress, ProgressIndicator, ProgressLabel, type ProgressProps, ProgressTrack, ProgressValue, Radar, RadarChart, RadioGroup, RadioGroupItem, type RadioGroupItemProps, type RadioGroupProps, RechartsLegend, RechartsTooltip, ReferenceLine, type ResolvedCortenaTheme, ResponsiveContainer, Scatter, ScatterChart, ScrollArea, type ScrollAreaProps, ScrollBar, SectionCard, type SectionCardProps, Segmented, type SegmentedOption, type SegmentedProps, Select, SelectContent, type SelectContentProps, SelectGroup, SelectItem, SelectLabel, SelectSeparator, SelectTrigger, type SelectTriggerProps, SelectValue, Separator, type SeparatorProps, type ServerSource, Sheet, SheetClose, SheetContent, type SheetContentProps, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Skeleton, SortableHandle, type SortableHandleProps, SortableList, type SortableListProps, type SortableRenderState, Spinner, type SpinnerProps, StatusDot, type StatusDotProps, type StatusDotTone, type SubmitHandler, Switch, type SwitchProps, type TableQuery, type TableResult, Tabs, TabsContent, TabsIndicator, TabsList, TabsTrigger, Textarea, type TextareaProps, Toast, type ToastProps, Toaster, type ToasterProps, Toolbar, ToolbarEnd, type ToolbarProps, ToolbarSeparator, ToolbarStart, Tooltip, TooltipContent, type TooltipContentProps, TooltipProvider, TooltipTrigger, type UseCortenaThemeOptions, type UseCortenaThemeResult, type UseDataTableOptions, type UseFormFieldReturn, type UseFormReturn, XAxis, YAxis, alertVariants, arrayMove, badgeVariants, buttonVariants, chipVariants, fieldVariants, formatDateDefault, formatDateISO, formatDateLong, formatDateShort, formatFileSize, formatRelative, inputClassName, labelVariants, markdownSanitizeSchema, parseDateDefault, parseDateISO, sheetVariants, textareaClassName, toastVariants, useComboboxFilter, useForm, useFormField, useToast, zodResolver };
 //# sourceMappingURL=index.d.ts.map