basalt-ui 1.24.0 → 1.26.0

package/dist/data/data-table.d.ts

@@ -1,5 +1,5 @@
 import type { MantineSpacing } from '@mantine/core';
-import type { ColumnDef, ColumnPinningState, PaginationState, RowData, SortingState } from '@tanstack/react-table';
+import type { ColumnDef, ColumnFiltersState, ColumnPinningState, PaginationState, RowData, SortingState } from '@tanstack/react-table';
 import type { ReactNode } from 'react';
 /** Horizontal alignment of a column's header AND its cells. */
 export type DataTableAlign = 'left' | 'center' | 'right';
@@ -24,16 +24,16 @@ declare module '@tanstack/react-table' {
         numeral?: boolean;
     }
 }
-/** A single selectable option inside a {@link DataTableFacet}'s Select/MultiSelect. */
+/** A single selectable option inside a {@link DataTableFacet}'s `EnumFilter`/`MultiSelectFilter` pill. */
 export type DataTableFacetOption = {
     /** The raw filter value, compared against the column's stringified cell value. */
     value: string;
-    /** Label shown in the Select/MultiSelect dropdown. */
+    /** Label shown in the pill's popover. */
     label: string;
 };
 /**
- * Declares one faceted column filter, rendered as a Mantine Select (or MultiSelect when
- * `multiple` is set) inside the toolbar.
+ * Declares one faceted column filter, rendered as an `EnumFilter` pill (or `MultiSelectFilter`
+ * when `multiple` is set) inside a `FilterSet` in the toolbar (`docs/CONTROLS-SPEC.md` §3).
  *
  * @example
  * const facets: DataTableFacet[] = [
@@ -45,11 +45,11 @@ export type DataTableFacetOption = {
 export type DataTableFacet = {
     /** The TanStack column id — the column's manual `id`, or its `accessorKey` string. */
     columnId: string;
-    /** Label shown as the Select/MultiSelect placeholder. */
+    /** The pill's label — read at rest (single-select) and as the `Filters`/count fallback (multi). */
     label: string;
     /** Selectable options for this facet. */
     options: DataTableFacetOption[];
-    /** Render a MultiSelect (any-of match) instead of a single Select (exact match). @default false */
+    /** Render a `MultiSelectFilter` (any-of match) instead of an `EnumFilter` (exact match). @default false */
     multiple?: boolean;
 };
 /**
@@ -66,6 +66,16 @@ export type DataTableFacet = {
  * }
  */
 export type BasaltDataTableProps<T> = {
+    /**
+     * Optional heading rendered above the toolbar via `WidgetHeader tier="widget"`. `count` always
+     * reads `table.getRowCount()` (C11) — never a raw `data.length` — so it tracks the row model
+     * (post-filter/-pagination) rather than the unfiltered input.
+     */
+    title?: string;
+    /** Optional leading icon, forwarded to `WidgetHeader`. */
+    icon?: ReactNode;
+    /** Optional muted line rendered below the title row. */
+    subtitle?: string;
     /** Row data array. */
     data: T[];
     /**
@@ -74,15 +84,43 @@ export type BasaltDataTableProps<T> = {
      */
     columns: ColumnDef<T, any>[];
     /**
-     * Enable column sorting via clickable headers.
+     * Enable column sorting via clickable headers. Client-side — the rows in `data` are what get
+     * reordered.
+     *
+     * Under `manualPagination` that is one page, so leaving this on without also passing
+     * `manualSorting` is a contract violation and throws in dev — see `manualPagination`.
      * @default true
      */
     enableSorting?: boolean;
+    /**
+     * Hand sorting to the server: the table stops reordering `data` locally and renders it in the
+     * order given, while the headers keep toggling `SortingState` and reporting it through
+     * `onSortingChange` — which is where you re-request the sorted page.
+     *
+     * This is the required companion to `manualPagination` whenever sort headers are live; without
+     * it a server-paginated table sorts one page and the "of N" bar presents that as a sort of all N.
+     * @default false
+     * @example
+     * <BasaltDataTable
+     *   data={page.rows}
+     *   columns={columns}
+     *   enablePagination
+     *   manualPagination
+     *   manualSorting
+     *   rowCount={page.total}
+     *   onSortingChange={(s) => refetch({ sort: s[0] })}
+     * />
+     */
+    manualSorting?: boolean;
     /** Stripe alternate rows. Forwarded to Mantine `Table` — `'odd'`/`'even'` pick the phase. */
     striped?: boolean | 'odd' | 'even';
     /** Highlight hovered rows. Forwarded to Mantine `Table`. */
     highlightOnHover?: boolean;
-    /** Rendered when `data` is empty. Falls back to a simple message when omitted. */
+    /**
+     * Rendered when no rows are VISIBLE — `data` is empty, or a filter/page matches none of it.
+     * Falls back to a simple message when omitted. (Before 1.25.0 this tracked `data.length` alone,
+     * so a search matching nothing rendered a blank `<tbody>` with no message at all.)
+     */
     emptyState?: ReactNode;
     /**
      * When true, renders skeleton placeholder rows instead of the empty-state branch.
@@ -134,18 +172,31 @@ export type BasaltDataTableProps<T> = {
     /** Called whenever the internal global filter value changes. */
     onGlobalFilterChange?: (value: string) => void;
     /**
-     * Faceted column filters, rendered in the toolbar as Mantine Select/MultiSelect controls wired
-     * to TanStack's per-column `columnFilters` state. The toolbar renders whenever this array is
-     * non-empty, `enableGlobalFilter` is set, or `toolbarActions` is passed.
+     * Faceted column filters, rendered in the toolbar as `EnumFilter`/`MultiSelectFilter` pills
+     * inside a `FilterSet`, wired to TanStack's per-column `columnFilters` state. The toolbar
+     * renders whenever this array is non-empty, `enableGlobalFilter` is set, or `actions` is passed.
      * @example
      * facets={[{ columnId: 'department', label: 'Department', options: departmentOptions }]}
      */
     facets?: DataTableFacet[];
+    /** Called whenever the faceted column filters change — the seam for server-side faceting. */
+    onColumnFiltersChange?: (filters: ColumnFiltersState) => void;
+    /**
+     * Hand filtering to the server: the table stops narrowing `data` locally and renders every row
+     * given, while the search input and facets keep reporting through `onGlobalFilterChange` /
+     * `onColumnFiltersChange` — which is where you re-request the filtered page.
+     *
+     * Required alongside `manualPagination` whenever `enableGlobalFilter` or `facets` is set;
+     * without it the controls narrow one page while "of N" keeps counting the whole set.
+     * @default false
+     */
+    manualFiltering?: boolean;
     /**
      * Right-aligned toolbar slot (e.g. an "Export" button). Renders the toolbar row even when no
-     * search input or facets are configured.
+     * search input or facets are configured. Renamed from `toolbarActions` — the toolbar (search +
+     * facets + this slot) is wrapped in `CtlSlot` (C1/C5), so its controls resolve to the `ctl` tier.
      */
-    toolbarActions?: ReactNode;
+    actions?: ReactNode;
     /**
      * Enables the bottom pagination bar ("Showing X–Y of N", rows-per-page `Select`, Mantine
      * `Pagination`) wired to TanStack's `pagination` state. Client-side by default — see
@@ -169,6 +220,21 @@ export type BasaltDataTableProps<T> = {
      * Disables local pagination slicing — pass the already-paginated page of `data` plus `rowCount`
      * (and optionally `pageCount`) for server-driven pagination. `onPaginationChange` is where you
      * fetch the next page.
+     *
+     * **It imposes a contract, enforced at render.** `data` is now one page, but the pagination bar
+     * says "Showing 1–25 of 412" — so every OTHER client-side control becomes a claim about 412 rows
+     * that it can only make about 25. Each has to be resolved explicitly, because only the call site
+     * knows whether the server does the work:
+     *
+     * - `rowCount` (or `pageCount`) must be given, or "of N" counts the page and the pager collapses
+     *   to a single page nobody can leave;
+     * - sorting must be handed over with `manualSorting`, or switched off with `enableSorting={false}`;
+     * - `enableGlobalFilter` / `facets`, if used, must be handed over with `manualFiltering`;
+     * - `enablePagination` must be on, or `manualPagination` is inert and the page renders as if it
+     *   were the whole table.
+     *
+     * Unresolved, each throws in dev and degrades to the honest render in production (no sort
+     * headers, no filter controls, no "of N") — never to the plausible wrong answer.
      * @default false
      * @example
      * <BasaltDataTable
@@ -225,9 +291,20 @@ export type BasaltDataTableProps<T> = {
     /** Row separators. Forwarded to Mantine `Table`. @default true (Mantine's own default) */
     withRowBorders?: boolean;
     /**
-     * Outer table border. Turn it OFF for a table that already sits inside a `Card`/`ChartCard`,
-     * where the card owns the frame and a second one reads as a nested box.
-     * @default true
+     * Outer table border — a full box around the table.
+     *
+     * **`false` by default since this minor** (it was `true`). Three separate faults, all visible on
+     * the playground's `Controls (mobile)` page at 390px: its TOP edge sat directly under the table's
+     * own `WidgetHeader`, separating a header from its own content; its BOTTOM edge landed on the last
+     * row's own hairline, two rules at zero distance; and its left/right edges carried no information
+     * at all on a table that fills the page (`docs/DESIGN-SPEC.md` §8 — a border is a layout divider,
+     * and there is nothing here to divide). The head-row rule and the between-row rules stay, so the
+     * table still reads as a table.
+     *
+     * Pass `true` for a table that genuinely needs a frame — a small table floating in whitespace
+     * beside other content, where the box IS the grouping.
+     *
+     * @default false
      */
     withTableBorder?: boolean;
 };
@@ -235,8 +312,13 @@ export type BasaltDataTableProps<T> = {
  * A sortable data table backed by TanStack Table and rendered with Mantine primitives.
  * Generic over `T` — column types are inferred from `ColumnDef<T>`.
  *
- * Sorting is local/client-side (no `any`). When `enableSorting` is `false` the table
- * is read-only. An `emptyState` node is rendered when `data` is empty.
+ * Sorting is local/client-side by default (no `any`); `manualSorting` hands it to the server.
+ * When `enableSorting` is `false` the table is read-only. An `emptyState` node is rendered
+ * whenever no rows are visible — empty `data`, or a filter that matches none of it.
+ *
+ * `manualPagination` imposes a contract on the rest of the props (see its docblock): every
+ * client-side control it would turn into a false claim about the unseen rows must be handed to the
+ * server or switched off, and an unresolved one throws in dev rather than misreporting.
  *
  * Toolbar (search + facets), pagination, and column pinning are opt-in chrome layered on top —
  * see the corresponding props below. None of them change rendering unless explicitly enabled.
@@ -251,5 +333,5 @@ export type BasaltDataTableProps<T> = {
  *   emptyState={<Text c="dimmed">No users found.</Text>}
  * />
  */
-export declare function BasaltDataTable<T>({ data, columns, enableSorting, striped, highlightOnHover, emptyState, isLoading, skeletonRows, initialSorting, onSortingChange, enableGlobalFilter, globalFilterPlaceholder, searchIcon, initialGlobalFilter, onGlobalFilterChange, facets, toolbarActions, enablePagination, pageSizeOptions, initialPagination, onPaginationChange, manualPagination, rowCount, pageCount, enablePinning, initialColumnPinning, maxHeight, minWidth, stickyHeader, stickyHeaderOffset, verticalSpacing, horizontalSpacing, withRowBorders, withTableBorder, }: BasaltDataTableProps<T>): import("react").JSX.Element;
+export declare function BasaltDataTable<T>({ title, icon, subtitle, data, columns, enableSorting, manualSorting, striped, highlightOnHover, emptyState, isLoading, skeletonRows, initialSorting, onSortingChange, enableGlobalFilter, globalFilterPlaceholder, searchIcon, initialGlobalFilter, onGlobalFilterChange, facets, onColumnFiltersChange, manualFiltering, actions, enablePagination, pageSizeOptions, initialPagination, onPaginationChange, manualPagination, rowCount, pageCount, enablePinning, initialColumnPinning, maxHeight, minWidth, stickyHeader, stickyHeaderOffset, verticalSpacing, horizontalSpacing, withRowBorders, withTableBorder, }: BasaltDataTableProps<T>): import("react").JSX.Element;
 //# sourceMappingURL=data-table.d.ts.map

package/dist/data/data-table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-table.d.ts","sourceRoot":"","sources":["../../src/data/data-table.tsx"],"names":[],"mappings":"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"}
+{"version":3,"file":"data-table.d.ts","sourceRoot":"","sources":["../../src/data/data-table.tsx"],"names":[],"mappings":"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"}

package/dist/data/data-table.js

@@ -1,15 +1,5 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import {
-  Box,
-  Group,
-  MultiSelect,
-  Pagination,
-  Select,
-  Skeleton,
-  Table,
-  Text,
-  TextInput
-} from "@mantine/core";
+import { Box, Group, Pagination, Select, Skeleton, Table, Text, TextInput } from "@mantine/core";
 import {
   flexRender,
   getCoreRowModel,
@@ -19,7 +9,12 @@ import {
   useReactTable
 } from "@tanstack/react-table";
 import { useCallback, useMemo, useState } from "react";
+import { FilterSet } from "../controls/index.js";
+import { EnumFilter } from "../controls/enum-filter.js";
+import { MultiSelectFilter } from "../controls/multi-select-filter.js";
+import { CtlSlot } from "../theme/index.js";
 import { alpha, VX } from "../tokens/index.js";
+import { WidgetHeader } from "../widget-header/index.js";
 const ALIGNMENTS = /* @__PURE__ */ new Set(["left", "center", "right"]);
 function resolveAlign(column) {
   const align = column.columnDef.meta?.align;
@@ -31,6 +26,44 @@ function resolveAlign(column) {
   }
   return align;
 }
+const FACET_ALL_VALUE = "__basalt_facet_all__";
+function facetAllLabel(facet) {
+  return `Any ${facet.label.toLowerCase()}`;
+}
+function facetEnumHandle(column, facet) {
+  return {
+    kind: "enum",
+    fallback: FACET_ALL_VALUE,
+    options: [{ value: FACET_ALL_VALUE, label: facetAllLabel(facet) }, ...facet.options],
+    use: () => {
+      const current = column.getFilterValue() ?? FACET_ALL_VALUE;
+      return [
+        current,
+        (next) => {
+          column.setFilterValue(next === FACET_ALL_VALUE ? void 0 : next);
+        }
+      ];
+    },
+    isDefault: (value) => value === FACET_ALL_VALUE
+  };
+}
+function facetMultiHandle(column, facet) {
+  return {
+    kind: "multi",
+    fallback: [],
+    options: facet.options,
+    use: () => {
+      const current = column.getFilterValue() ?? [];
+      return [
+        current,
+        (next) => {
+          column.setFilterValue(next.length > 0 ? [...next] : void 0);
+        }
+      ];
+    },
+    isDefault: (value) => value.length === 0
+  };
+}
 function SortIndicator({ direction }) {
   if (!direction) return null;
   return /* @__PURE__ */ jsx(Box, { component: "span", ml: 4, "aria-hidden": true, children: direction === "asc" ? "\u2191" : "\u2193" });
@@ -49,6 +82,10 @@ const RANGE_LABEL_STYLE = {
   color: "var(--vx-faint)"
 };
 const DEFAULT_PAGE_SIZE_OPTIONS = [10, 25, 50, 100];
+const TABLE_HEADER_LEAD_STYLE = { flex: "1 1 auto", minWidth: 0 };
+const TABLE_TOOLBAR_STYLE = { flex: "0 0 auto" };
+const SEARCH_WIDTH = 220;
+const PAGE_SIZE_WIDTH = 116;
 function getOrderedHeaderGroups(table) {
   const left = table.getLeftHeaderGroups();
   const center = table.getCenterHeaderGroups();
@@ -85,10 +122,46 @@ function getPinnedCellStyle(table, column) {
     boxShadow: isEdge ? `-4px 0 6px -4px ${alpha(VX.ink, 0.18)}` : void 0
   };
 }
+function isDev() {
+  return process.env["NODE_ENV"] !== "production";
+}
+const BREACH_REMEDY = {
+  inert: "`enablePagination` is not set, so `manualPagination` never reaches the table and the server page renders as if it were the whole set, with no bar to say otherwise. Pass `enablePagination`, or drop `manualPagination`.",
+  total: 'neither `rowCount` nor `pageCount` was given, so "of N" counts only the rows on this page and the pager collapses to one page nobody can leave. Pass `rowCount={total}`.',
+  sorting: 'client-side sorting is still armed. It reorders only the rows in `data` \u2014 one page \u2014 while the header chevron and "of N" together present it as a sort of all of them. Pass `manualSorting` and sort in the request you make from `onSortingChange`, or `enableSorting={false}`.',
+  filtering: 'the search input / facets still filter client-side. They narrow only the rows in `data` \u2014 one page \u2014 while "of N" keeps counting the whole set. Pass `manualFiltering` and filter in the request you make from `onGlobalFilterChange` / `onColumnFiltersChange`, or drop `enableGlobalFilter` / `facets`.'
+};
+function manualPaginationBreaches(config) {
+  if (!config.manualPagination) return [];
+  if (!config.enablePagination) return ["inert"];
+  const breaches = [];
+  if (config.rowCount === void 0 && config.pageCount === void 0) breaches.push("total");
+  const anyColumnMaySort = config.columns.some((column) => column.enableSorting !== false);
+  if (config.enableSorting && anyColumnMaySort && !config.manualSorting) breaches.push("sorting");
+  if ((config.enableGlobalFilter || config.hasFacets) && !config.manualFiltering)
+    breaches.push("filtering");
+  return breaches;
+}
+function manualPaginationMessage(breaches) {
+  return "BasaltDataTable: `manualPagination` is set, so `data` is one server page \u2014 but:\n  \xB7 " + breaches.map((breach) => BREACH_REMEDY[breach]).join("\n  \xB7 ") + "\nEach has to be resolved explicitly: only the call site knows whether the server does the work, so there is no default that is not a guess about the data.";
+}
+const reportedBreaches = /* @__PURE__ */ new Set();
+function enforceManualPaginationContract(breaches) {
+  if (breaches.length === 0) return;
+  const message = manualPaginationMessage(breaches);
+  if (isDev()) throw new Error(message);
+  if (reportedBreaches.has(message)) return;
+  reportedBreaches.add(message);
+  console.error(message);
+}
 function BasaltDataTable({
+  title,
+  icon,
+  subtitle,
   data,
   columns,
   enableSorting = true,
+  manualSorting = false,
   striped,
   highlightOnHover,
   emptyState,
@@ -102,7 +175,9 @@ function BasaltDataTable({
   initialGlobalFilter,
   onGlobalFilterChange,
   facets,
-  toolbarActions,
+  onColumnFiltersChange,
+  manualFiltering = false,
+  actions,
   enablePagination = false,
   pageSizeOptions = DEFAULT_PAGE_SIZE_OPTIONS,
   initialPagination,
@@ -119,7 +194,7 @@ function BasaltDataTable({
   verticalSpacing,
   horizontalSpacing,
   withRowBorders,
-  withTableBorder = true
+  withTableBorder = false
 }) {
   const [sorting, setSorting] = useState(initialSorting ?? []);
   const [globalFilter, setGlobalFilter] = useState(initialGlobalFilter ?? "");
@@ -148,6 +223,16 @@ function BasaltDataTable({
     },
     [onGlobalFilterChange]
   );
+  const handleColumnFiltersChange = useCallback(
+    (updater) => {
+      setColumnFilters((prev) => {
+        const next = typeof updater === "function" ? updater(prev) : updater;
+        onColumnFiltersChange?.(next);
+        return next;
+      });
+    },
+    [onColumnFiltersChange]
+  );
   const handlePaginationChange = useCallback(
     (updater) => {
       setPagination((prev) => {
@@ -170,6 +255,23 @@ function BasaltDataTable({
       return { ...column, filterFn };
     });
   }, [columns, facets]);
+  const hasFacets = Boolean(facets && facets.length > 0);
+  const breaches = manualPaginationBreaches({
+    columns,
+    enablePagination,
+    manualPagination,
+    rowCount,
+    pageCount,
+    enableSorting,
+    manualSorting,
+    enableGlobalFilter,
+    hasFacets,
+    manualFiltering
+  });
+  enforceManualPaginationContract(breaches);
+  const sortingEnabled = enableSorting && !breaches.includes("sorting");
+  const filteringEnabled = !breaches.includes("filtering");
+  const totalIsAuthoritative = !breaches.includes("total");
   const table = useReactTable({
     data,
     columns: tableColumns,
@@ -182,23 +284,33 @@ function BasaltDataTable({
     },
     onSortingChange: handleSortingChange,
     onGlobalFilterChange: handleGlobalFilterChange,
-    onColumnFiltersChange: setColumnFilters,
+    onColumnFiltersChange: handleColumnFiltersChange,
     onColumnPinningChange: setColumnPinning,
     ...enablePagination && { onPaginationChange: handlePaginationChange },
     getCoreRowModel: getCoreRowModel(),
     getSortedRowModel: getSortedRowModel(),
     getFilteredRowModel: getFilteredRowModel(),
+    // Both row models stay installed and are BYPASSED by these flags, which is TanStack's own
+    // seam — so a degraded table renders `data` in the order and completeness the server sent it.
+    // Forced only by a BREACH, never by `enableSorting={false}` on its own: that pair still applies
+    // an `initialSorting` today (it disables the header control, not the row model) and a table
+    // that is not misreporting has no business losing it.
+    manualSorting: manualSorting || breaches.includes("sorting"),
+    manualFiltering: manualFiltering || breaches.includes("filtering"),
     ...enablePagination && {
       getPaginationRowModel: getPaginationRowModel(),
       manualPagination,
       ...manualPagination && rowCount !== void 0 && { rowCount },
       ...manualPagination && pageCount !== void 0 && { pageCount }
     },
-    enableSorting,
+    enableSorting: sortingEnabled,
     enableColumnPinning: enablePinning
   });
-  const showToolbar = enableGlobalFilter || Boolean(facets && facets.length > 0) || Boolean(toolbarActions);
+  const showSearch = enableGlobalFilter && filteringEnabled;
+  const showFacets = hasFacets && filteringEnabled;
+  const showToolbar = showSearch || showFacets || Boolean(actions);
   const headerGroups = enablePinning ? getOrderedHeaderGroups(table) : table.getHeaderGroups();
+  const rows = table.getRowModel().rows;
   const tableNode = /* @__PURE__ */ jsxs(
     Table,
     {
@@ -212,7 +324,7 @@ function BasaltDataTable({
       withTableBorder,
       children: [
         /* @__PURE__ */ jsx(Table.Thead, { children: headerGroups.map((headerGroup) => /* @__PURE__ */ jsx(Table.Tr, { children: headerGroup.headers.map((header) => {
-          const canSort = enableSorting && header.column.getCanSort();
+          const canSort = sortingEnabled && header.column.getCanSort();
           const sorted = header.column.getIsSorted();
           const toggleSorting = header.column.getToggleSortingHandler();
           const pinnedStyle = enablePinning ? getPinnedCellStyle(table, header.column) : void 0;
@@ -241,7 +353,7 @@ function BasaltDataTable({
             header.id
           );
         }) }, headerGroup.id)) }),
-        /* @__PURE__ */ jsx(Table.Tbody, { children: isLoading ? Array.from({ length: skeletonRows }, (_, rowIndex) => /* @__PURE__ */ jsx(Table.Tr, { children: columns.map((_2, colIndex) => /* @__PURE__ */ jsx(Table.Td, { children: /* @__PURE__ */ jsx(Skeleton, { height: 16, radius: "sm" }) }, `skeleton-${rowIndex}-${colIndex}`)) }, `skeleton-${rowIndex}`)) : data.length === 0 ? /* @__PURE__ */ jsx(Table.Tr, { children: /* @__PURE__ */ jsx(Table.Td, { colSpan: columns.length, children: emptyState ?? /* @__PURE__ */ jsx(Text, { c: "dimmed", ta: "center", size: "sm", py: "sm", children: "No data to display." }) }) }) : table.getRowModel().rows.map((row) => {
+        /* @__PURE__ */ jsx(Table.Tbody, { children: isLoading ? Array.from({ length: skeletonRows }, (_, rowIndex) => /* @__PURE__ */ jsx(Table.Tr, { children: columns.map((_2, colIndex) => /* @__PURE__ */ jsx(Table.Td, { children: /* @__PURE__ */ jsx(Skeleton, { height: 16, radius: "sm" }) }, `skeleton-${rowIndex}-${colIndex}`)) }, `skeleton-${rowIndex}`)) : rows.length === 0 ? /* @__PURE__ */ jsx(Table.Tr, { children: /* @__PURE__ */ jsx(Table.Td, { colSpan: columns.length, children: emptyState ?? /* @__PURE__ */ jsx(Text, { c: "dimmed", ta: "center", size: "sm", py: "sm", children: "No data to display." }) }) }) : rows.map((row) => {
           const cells = enablePinning ? [
             ...row.getLeftVisibleCells(),
             ...row.getCenterVisibleCells(),
@@ -269,62 +381,55 @@ function BasaltDataTable({
   );
   const scrolls = maxHeight !== void 0 || minWidth !== void 0;
   const paginationState = table.getState().pagination;
+  const pageSizeRows = [.../* @__PURE__ */ new Set([...pageSizeOptions, paginationState.pageSize])].sort((a, b) => a - b).map((size) => ({ value: String(size), label: `${size} / page` }));
   const total = table.getRowCount();
   const rangeStart = total === 0 ? 0 : paginationState.pageIndex * paginationState.pageSize + 1;
   const rangeEnd = Math.min((paginationState.pageIndex + 1) * paginationState.pageSize, total);
   return /* @__PURE__ */ jsxs(Fragment, { children: [
-    showToolbar && /* @__PURE__ */ jsxs(Group, { justify: "space-between", align: "flex-end", wrap: "wrap", gap: "xs", mb: "xs", children: [
-      /* @__PURE__ */ jsxs(Group, { gap: "xs", wrap: "wrap", align: "flex-end", children: [
-        enableGlobalFilter && /* @__PURE__ */ jsx(
+    (title !== void 0 || showToolbar) && /* @__PURE__ */ jsxs(Group, { justify: "space-between", align: "center", wrap: "wrap", gap: "xs", mb: "xs", children: [
+      title !== void 0 ? /* @__PURE__ */ jsx(Box, { style: TABLE_HEADER_LEAD_STYLE, children: /* @__PURE__ */ jsx(
+        WidgetHeader,
+        {
+          tier: "widget",
+          title,
+          ...icon !== void 0 && { icon },
+          ...subtitle !== void 0 && { subtitle },
+          count: table.getRowCount()
+        }
+      ) }) : null,
+      showToolbar && /* @__PURE__ */ jsx(CtlSlot, { children: /* @__PURE__ */ jsxs(Group, { gap: "xs", wrap: "wrap", align: "center", style: TABLE_TOOLBAR_STYLE, children: [
+        showSearch && /* @__PURE__ */ jsx(
           TextInput,
           {
-            size: "xs",
             radius: "md",
+            w: SEARCH_WIDTH,
             placeholder: globalFilterPlaceholder,
             leftSection: searchIcon,
             value: globalFilter,
-            onChange: (event) => handleGlobalFilterChange(event.currentTarget.value),
-            w: 220
+            onChange: (event) => handleGlobalFilterChange(event.currentTarget.value)
           }
         ),
-        facets?.map((facet) => {
+        showFacets && /* @__PURE__ */ jsx(FilterSet, { children: facets?.map((facet) => {
           const column = table.getColumn(facet.columnId);
           if (!column) return null;
-          if (facet.multiple) {
-            const value2 = column.getFilterValue() ?? [];
-            return /* @__PURE__ */ jsx(
-              MultiSelect,
-              {
-                size: "xs",
-                radius: "md",
-                placeholder: facet.label,
-                data: facet.options,
-                value: value2,
-                onChange: (next) => column.setFilterValue(next.length > 0 ? next : void 0),
-                clearable: true,
-                w: 200
-              },
-              facet.columnId
-            );
-          }
-          const value = column.getFilterValue() ?? null;
-          return /* @__PURE__ */ jsx(
-            Select,
+          return facet.multiple ? /* @__PURE__ */ jsx(
+            MultiSelectFilter,
             {
-              size: "xs",
-              radius: "md",
-              placeholder: facet.label,
-              data: facet.options,
-              value,
-              onChange: (next) => column.setFilterValue(next ?? void 0),
-              clearable: true,
-              w: 180
+              field: facetMultiHandle(column, facet),
+              label: facet.label
+            },
+            facet.columnId
+          ) : /* @__PURE__ */ jsx(
+            EnumFilter,
+            {
+              field: facetEnumHandle(column, facet),
+              label: facet.label
             },
             facet.columnId
           );
-        })
-      ] }),
-      toolbarActions
+        }) }),
+        actions
+      ] }) })
     ] }),
     scrolls ? /* @__PURE__ */ jsx(
       Table.ScrollContainer,
@@ -341,23 +446,19 @@ function BasaltDataTable({
         rangeStart,
         "\u2013",
         rangeEnd,
-        " of ",
-        total
+        totalIsAuthoritative ? ` of ${total}` : ""
       ] }),
       /* @__PURE__ */ jsxs(Group, { gap: "xs", align: "center", children: [
         /* @__PURE__ */ jsx(
           Select,
           {
-            size: "xs",
+            size: "ctl",
             radius: "md",
-            data: pageSizeOptions.map((size) => ({
-              value: String(size),
-              label: `${size} / page`
-            })),
+            w: PAGE_SIZE_WIDTH,
+            data: pageSizeRows,
             value: String(paginationState.pageSize),
             onChange: (value) => value && table.setPageSize(Number(value)),
-            allowDeselect: false,
-            w: 110
+            allowDeselect: false
           }
         ),
         /* @__PURE__ */ jsx(

package/dist/data/table.d.ts

@@ -20,5 +20,5 @@
  */
 export { BasaltDataTable } from './data-table.js';
 export type { BasaltDataTableProps, DataTableAlign, DataTableFacet, DataTableFacetOption, } from './data-table.js';
-export { createColumnHelper, useReactTable, flexRender, getCoreRowModel, getSortedRowModel, getFilteredRowModel, getPaginationRowModel, type ColumnDef, type SortingState, type ColumnHelper, type PaginationState, type ColumnPinningState, } from '@tanstack/react-table';
+export { createColumnHelper, useReactTable, flexRender, getCoreRowModel, getSortedRowModel, getFilteredRowModel, getPaginationRowModel, type ColumnDef, type SortingState, type ColumnHelper, type PaginationState, type ColumnPinningState, type ColumnFiltersState, } from '@tanstack/react-table';
 //# sourceMappingURL=table.d.ts.map

package/dist/data/table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/data/table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,YAAY,EACV,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,oBAAoB,GACrB,MAAM,cAAc,CAAA;AASrB,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,kBAAkB,GACxB,MAAM,uBAAuB,CAAA"}
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/data/table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,YAAY,EACV,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,oBAAoB,GACrB,MAAM,cAAc,CAAA;AASrB,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EAEvB,KAAK,kBAAkB,GACxB,MAAM,uBAAuB,CAAA"}

package/dist/guard/grace.test.d.ts

@@ -0,0 +1,20 @@
+type GraceEntry = {
+    since: string;
+    promote: string;
+    why: string;
+};
+/**
+ * Tiny local semver compare — no dependency. Assumes plain `x.y.z`, no pre-release identifiers
+ * (basalt-ui bans majors and ships no pre-releases). Returns negative when `a` sorts before `b`,
+ * positive when after, zero when equal. Compares each component numerically, not lexically, so
+ * `'1.9.0' < '1.10.0'` and `'1.3.0' < '1.26.0'` — a string compare would get both backwards.
+ */
+export declare function compareSemver(a: string, b: string): number;
+/**
+ * The C16 gate itself, extracted so it can be exercised against a synthetic ledger as well as the
+ * real one. Throws naming the first offending entry when either invariant breaks: `since` must
+ * precede `promote` for every entry, and no entry's `promote` may be `<=` the given `version`.
+ */
+export declare function assertGraceLedger(ledger: Record<string, GraceEntry>, version: string): void;
+export {};
+//# sourceMappingURL=grace.test.d.ts.map

package/dist/guard/grace.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grace.test.d.ts","sourceRoot":"","sources":["../../src/guard/grace.test.ts"],"names":[],"mappings":"AA8BA,KAAK,UAAU,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAEjE;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAc3F"}