@ai-matrx/design-system 0.22.0 → 0.26.0

package/dist/data-table/index.js

@@ -5,13 +5,13 @@ import {
   cloneElement as cloneElement2,
   Fragment as Fragment6,
   isValidElement as isValidElement2,
-  useCallback as useCallback7,
-  useEffect as useEffect15,
+  useCallback as useCallback8,
+  useEffect as useEffect16,
   useId as useId2,
   useLayoutEffect as useLayoutEffect2,
-  useMemo as useMemo7,
-  useRef as useRef13,
-  useState as useState21
+  useMemo as useMemo8,
+  useRef as useRef15,
+  useState as useState22
 } from "react";
 import {
   DndContext,
@@ -5139,10 +5139,10 @@ function passesColumnFilter(value, filter) {
         if (raw === "") return false;
         const normalized = raw.replace(/[^0-9.-]/g, "");
         if (normalized === "") return false;
-        const n = typeof value === "number" ? value : Number(normalized);
-        if (!Number.isFinite(n)) return false;
-        if (filter.min !== void 0 && n < filter.min) return false;
-        if (filter.max !== void 0 && n > filter.max) return false;
+        const n2 = typeof value === "number" ? value : Number(normalized);
+        if (!Number.isFinite(n2)) return false;
+        if (filter.min !== void 0 && n2 < filter.min) return false;
+        if (filter.max !== void 0 && n2 > filter.max) return false;
         return true;
       }
     }
@@ -5205,26 +5205,26 @@ function filterAndSortRows(rows, columns, columnFilters, sort, globalSearch, any
   return result;
 }
 function countActiveColumnFilters(filters) {
-  let n = 0;
+  let n2 = 0;
   for (const f of Object.values(filters)) {
     if (!f) continue;
     switch (f.kind) {
       case "text":
-        if (f.value.trim() || f.mode && f.mode !== "contains") n += 1;
+        if (f.value.trim() || f.mode && f.mode !== "contains") n2 += 1;
         break;
       case "select":
         if (f.values !== void 0 || f.value && f.value !== "__all__")
-          n += 1;
+          n2 += 1;
         break;
       case "boolean":
-        n += 1;
+        n2 += 1;
         break;
       case "number":
-        if (f.min !== void 0 || f.max !== void 0) n += 1;
+        if (f.min !== void 0 || f.max !== void 0) n2 += 1;
         break;
     }
   }
-  return n;
+  return n2;
 }
 function isColumnFilterActive(filter) {
   if (!filter) return false;
@@ -5479,11 +5479,11 @@ import {
 } from "@ai-matrx/kit/url-state";
 function parseSort(raw) {
   if (!raw) return null;
-  const at = raw.lastIndexOf(".");
-  if (at <= 0) return null;
-  const direction = raw.slice(at + 1);
+  const at2 = raw.lastIndexOf(".");
+  if (at2 <= 0) return null;
+  const direction = raw.slice(at2 + 1);
   if (direction !== "asc" && direction !== "desc") return null;
-  return { id: raw.slice(0, at), direction };
+  return { id: raw.slice(0, at2), direction };
 }
 function parseObject(raw, fallback) {
   if (!raw) return fallback;
@@ -5506,8 +5506,8 @@ function parseLayeredFilters(raw) {
   }
 }
 function positiveInt(raw, fallback) {
-  const n = raw ? Number.parseInt(raw, 10) : Number.NaN;
-  return Number.isFinite(n) && n > 0 ? n : fallback;
+  const n2 = raw ? Number.parseInt(raw, 10) : Number.NaN;
+  return Number.isFinite(n2) && n2 > 0 ? n2 : fallback;
 }
 function tableUrlParamPrefix(tableId) {
   if (!/^[a-z][a-z0-9-]{0,63}$/.test(tableId)) {
@@ -5708,6 +5708,7 @@ import {
   forwardRef as forwardRef12,
   useEffect as useEffect9,
   useMemo as useMemo5,
+  useRef as useRef10,
   useState as useState14
 } from "react";
 import { useDraggable } from "@dnd-kit/core";
@@ -5855,6 +5856,95 @@ var CommandShortcut = ({
 };
 CommandShortcut.displayName = "CommandShortcut";
 
+// src/data-table/facets.ts
+var MAX_LISTABLE_FACET_LENGTH = 300;
+var DEFAULT_FACET_LIMIT = 200;
+var MAX_FACET_LIMIT = 500;
+function facetText(raw) {
+  if (raw === null || raw === void 0) return "";
+  if (typeof raw === "object") {
+    try {
+      return JSON.stringify(raw);
+    } catch {
+      return String(raw);
+    }
+  }
+  return String(raw);
+}
+function computeColumnFacets(args) {
+  const { columnId: columnId2, rows, readValue: readValue2 } = args;
+  const limit = Math.min(Math.max(args.limit ?? DEFAULT_FACET_LIMIT, 1), MAX_FACET_LIMIT);
+  const counts = /* @__PURE__ */ new Map();
+  const longValues = /* @__PURE__ */ new Set();
+  let blank = 0;
+  let maxLength = 0;
+  for (const row of rows) {
+    let raw;
+    try {
+      raw = readValue2(row, columnId2);
+    } catch {
+      raw = void 0;
+    }
+    const trimmed = facetText(raw).trim();
+    if (trimmed === "") {
+      blank += 1;
+      continue;
+    }
+    if (trimmed.length > maxLength) maxLength = trimmed.length;
+    if (trimmed.length > MAX_LISTABLE_FACET_LENGTH) {
+      longValues.add(trimmed);
+      continue;
+    }
+    counts.set(trimmed, (counts.get(trimmed) ?? 0) + 1);
+  }
+  const values = [...counts.entries()].map(([value, count]) => ({ value, count })).sort((a, b) => b.count - a.count || a.value.localeCompare(b.value)).slice(0, limit);
+  return {
+    columnId: columnId2,
+    totalRows: rows.length,
+    filled: rows.length - blank,
+    blank,
+    distinctCount: counts.size + longValues.size,
+    maxLength,
+    unlistable: longValues.size,
+    limit,
+    truncated: counts.size > limit,
+    values,
+    answeredBy: "local",
+    complete: args.complete ?? true
+  };
+}
+function localFacetsAreComplete(loadedRowCount, total) {
+  if (total === void 0 || !Number.isFinite(total) || total < 0) return false;
+  return loadedRowCount >= total;
+}
+var NUMBERS = new Intl.NumberFormat("en-US");
+function n(value) {
+  try {
+    return NUMBERS.format(value);
+  } catch {
+    return String(value);
+  }
+}
+function describeFacetSource(facets, noun = "row") {
+  if (!facets) return "";
+  const plural2 = `${noun}s`;
+  if (!facets.complete) {
+    return `These counts cover the ${n(facets.totalRows)} ${plural2} loaded here, not the whole table.`;
+  }
+  if (facets.truncated) {
+    return `Showing the ${n(facets.values.length)} most common of ${n(facets.distinctCount)} values.`;
+  }
+  if (facets.unlistable > 0) {
+    return `${n(facets.unlistable)} ${facets.unlistable === 1 ? "value is" : "values are"} too long to list. Match text instead to reach ${facets.unlistable === 1 ? "it" : "them"}.`;
+  }
+  return "";
+}
+var FACETS_LOADING_NOTICE = "Counting values\u2026";
+function describeFacetFailure(error) {
+  const detail = error instanceof Error ? error.message : String(error ?? "");
+  return detail ? `The values in this column could not be counted: ${detail} Match text instead.` : "The values in this column could not be counted. Match text instead.";
+}
+
 // src/data-table/column-marker.ts
 var MARKER_ACCESSORS = {
   favorite: "favorite",
@@ -5922,6 +6012,10 @@ function ColumnHeaderCell({
   filterFooterHint,
   allowNegation = false,
   allowNullModes = false,
+  facets,
+  facetsLoading = false,
+  facetsError,
+  onFilterOpen,
   reorderColumn
 }) {
   const reorderEnabled = reorderColumn !== void 0;
@@ -5956,6 +6050,11 @@ function ColumnHeaderCell({
       setPendingNegation(filterValue?.negated ?? false);
     }
   }, [filterOpen, filterValue]);
+  const notifyOpen = useRef10(onFilterOpen);
+  notifyOpen.current = onFilterOpen;
+  useEffect9(() => {
+    if (filterOpen) notifyOpen.current?.();
+  }, [filterOpen]);
   const applyFilter = () => {
     onFilterChange(draftFilter);
     setFilterOpen(false);
@@ -6050,6 +6149,9 @@ function ColumnHeaderCell({
             selectOptions,
             selectSingle,
             selectAllowCustom,
+            facets: facets ?? null,
+            facetsLoading,
+            ...facetsError === void 0 ? {} : { facetsError },
             ...markerLabels ? {
               booleanLabels: {
                 all: "All",
@@ -6274,8 +6376,43 @@ function FilterBody({
   selectSingle = false,
   selectAllowCustom = false,
   allowNullModes = false,
-  booleanLabels
+  booleanLabels,
+  facets = null,
+  facetsLoading = false,
+  facetsError
 }) {
+  const checklist = facetsLoading || facetsError || facets && (facets.values.length > 0 || facets.blank > 0) ? /* @__PURE__ */ jsx31(
+    FacetChecklist,
+    {
+      facets,
+      loading: facetsLoading,
+      ...facetsError === void 0 ? {} : { error: facetsError },
+      value,
+      onChange
+    }
+  ) : null;
+  if (checklist && kind === "select" && facets && facets.values.length > 0) {
+    return /* @__PURE__ */ jsx31("div", { className: "space-y-2", children: checklist });
+  }
+  if (checklist) {
+    return /* @__PURE__ */ jsxs22("div", { className: "space-y-2", children: [
+      checklist,
+      /* @__PURE__ */ jsx31("div", { className: "h-px bg-border" }),
+      /* @__PURE__ */ jsx31(
+        FilterBody,
+        {
+          kind,
+          value,
+          onChange,
+          selectOptions,
+          selectSingle,
+          selectAllowCustom,
+          allowNullModes,
+          ...booleanLabels === void 0 ? {} : { booleanLabels }
+        }
+      )
+    ] });
+  }
   if (kind === "text") {
     const text = value?.kind === "text" ? value.value : "";
     const mode = (value?.kind === "text" ? value.mode : void 0) ?? "contains";
@@ -6386,6 +6523,112 @@ function FilterBody({
   }
   return /* @__PURE__ */ jsx31(NumberFilterBody, { value, onChange });
 }
+function FacetChecklist({
+  facets,
+  loading,
+  error,
+  value,
+  onChange
+}) {
+  const [query, setQuery] = useState14("");
+  const selected = value?.kind === "select" ? value.values ?? (value.value && value.value !== "__all__" ? [value.value] : []) : [];
+  const selectedSet = new Set(selected);
+  const rows = useMemo5(() => {
+    if (!facets) return [];
+    const listed = facets.values.map((entry) => ({
+      value: entry.value,
+      label: entry.value,
+      count: entry.count
+    }));
+    const withBlank = facets.blank > 0 ? [{ value: "", label: "(empty)", count: facets.blank }, ...listed] : listed;
+    const q = query.trim().toLowerCase();
+    if (!q) return withBlank;
+    return withBlank.filter((row) => row.label.toLowerCase().includes(q));
+  }, [facets, query]);
+  const toggle = (candidate) => {
+    const next = new Set(selectedSet);
+    if (next.has(candidate)) next.delete(candidate);
+    else next.add(candidate);
+    const values = [...next];
+    onChange(
+      values.length === 0 ? void 0 : { kind: "select", value: values[0] ?? "", values }
+    );
+  };
+  const notice = error ?? (loading ? FACETS_LOADING_NOTICE : describeFacetSource(facets));
+  return /* @__PURE__ */ jsxs22("div", { className: "space-y-1.5", children: [
+    /* @__PURE__ */ jsx31("p", { className: "px-1 text-[11px] font-medium uppercase tracking-wider text-muted-foreground", children: "Values" }),
+    facets && facets.values.length + (facets.blank > 0 ? 1 : 0) > 8 ? /* @__PURE__ */ jsx31(
+      Input,
+      {
+        "data-matrx-filter-autofocus": true,
+        value: query,
+        onChange: (event) => setQuery(event.target.value),
+        placeholder: "Find a value\u2026",
+        className: "h-7 text-sm",
+        style: { fontSize: "16px" }
+      }
+    ) : null,
+    rows.length > 0 ? /* @__PURE__ */ jsx31("ul", { className: "max-h-56 space-y-0.5 overflow-y-auto", "data-matrx-facet-list": "true", children: rows.map((row) => {
+      const checked = selectedSet.has(row.value);
+      return /* @__PURE__ */ jsx31("li", { children: /* @__PURE__ */ jsxs22(
+        "button",
+        {
+          type: "button",
+          role: "checkbox",
+          "aria-checked": checked,
+          "data-matrx-facet-value": row.value === "" ? "__blank__" : row.value,
+          onClick: () => toggle(row.value),
+          className: cn(
+            "flex w-full items-center gap-2 rounded px-1.5 py-1 text-left text-xs hover:bg-muted",
+            checked && "bg-primary/10"
+          ),
+          children: [
+            /* @__PURE__ */ jsx31(
+              "span",
+              {
+                "aria-hidden": true,
+                className: cn(
+                  "flex h-3.5 w-3.5 shrink-0 items-center justify-center rounded-[3px] border",
+                  checked ? "border-primary bg-primary text-primary-foreground" : "border-border"
+                ),
+                children: checked ? /* @__PURE__ */ jsx31(Check, { className: "h-2.5 w-2.5" }) : null
+              }
+            ),
+            /* @__PURE__ */ jsx31("span", { className: cn("min-w-0 flex-1 truncate", row.value === "" && "italic text-muted-foreground"), children: row.label }),
+            /* @__PURE__ */ jsx31(
+              "span",
+              {
+                "data-matrx-facet-count": String(row.count),
+                className: "shrink-0 tabular-nums text-[11px] text-muted-foreground",
+                children: row.count.toLocaleString("en-US")
+              }
+            )
+          ]
+        }
+      ) }, row.value === "" ? "__blank__" : row.value);
+    }) }) : loading ? null : /* @__PURE__ */ jsx31("p", { className: "px-1 text-[11px] text-muted-foreground", children: query.trim() ? "No value matches that." : "This column has no values yet." }),
+    notice ? /* @__PURE__ */ jsx31(
+      "p",
+      {
+        "data-matrx-facet-notice": "true",
+        className: cn(
+          "px-1 text-[11px] leading-snug",
+          error ? "text-amber-700 dark:text-amber-400" : "text-muted-foreground"
+        ),
+        children: notice
+      }
+    ) : null,
+    selected.length > 0 ? /* @__PURE__ */ jsx31(
+      "button",
+      {
+        type: "button",
+        onClick: () => onChange(void 0),
+        className: "px-1 text-[11px] text-muted-foreground underline-offset-2 hover:underline",
+        children: "Clear selection"
+      }
+    ) : null
+  ] });
+}
 function SearchableSelectFilter({
   selected,
   options,
@@ -6572,15 +6815,15 @@ function NumberFilterBody({
 }
 function parseOptionalNumber(raw) {
   if (raw.trim() === "") return void 0;
-  const n = Number(raw.replace(/[^0-9.-]/g, ""));
-  return Number.isFinite(n) ? n : void 0;
+  const n2 = Number(raw.replace(/[^0-9.-]/g, ""));
+  return Number.isFinite(n2) ? n2 : void 0;
 }
 
 // src/data-table/ColumnResizeHandle.tsx
 import {
   useCallback as useCallback6,
   useEffect as useEffect10,
-  useRef as useRef10,
+  useRef as useRef11,
   useState as useState15
 } from "react";
 
@@ -6624,11 +6867,11 @@ function ColumnResizeHandle({
   onResizeCancel,
   onResizeCommit
 }) {
-  const handleRef = useRef10(null);
-  const activeResizeRef = useRef10(null);
-  const previewRafRef = useRef10(null);
-  const queuedWidthRef = useRef10(null);
-  const keyboardWidthRef = useRef10(null);
+  const handleRef = useRef11(null);
+  const activeResizeRef = useRef11(null);
+  const previewRafRef = useRef11(null);
+  const queuedWidthRef = useRef11(null);
+  const keyboardWidthRef = useRef11(null);
   const [announcedWidth, setAnnouncedWidth] = useState15(null);
   const bounds = resolveColumnResizeBounds(minWidth, maxWidth);
   const cssVar = columnResizeCssVar(columnId2);
@@ -6771,115 +7014,1768 @@ function projectColumnDragOrder(orderedIds, preview2) {
   return order;
 }
 
-// src/data-table/ranked-search.ts
-function inferTableSearchRole(field) {
-  const key = field.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase().replace(/[\s-]+/g, "_");
-  if (key === "id" || key === "uuid" || key.endsWith("_id")) return "id";
-  if (/^(name|alias|label|title|key|slug|display_name|common_name|model_name)$/.test(key) || /_(name|label|title)$/.test(key)) return "name";
-  if (/^(description|summary|details|notes|blurb)$/.test(key) || key.endsWith("_description")) return "description";
-  return "other";
+// src/data-table/grouping.ts
+var EMPTY_GROUP_KEY = "empty";
+var DEFAULT_EMPTY_LABEL = "(empty)";
+function isBlankGroupValue(value) {
+  return value === null || value === void 0 || value === "";
 }
-function searchableFields(row, columns) {
-  const values = /* @__PURE__ */ new Map();
-  if (row !== null && typeof row === "object") {
-    for (const [key, value] of Object.entries(row)) values.set(key, stringifyCellValue(value));
+function groupKeyOf(value) {
+  if (isBlankGroupValue(value)) return EMPTY_GROUP_KEY;
+  switch (typeof value) {
+    case "string":
+      return `s:${value}`;
+    case "number":
+      return `n:${String(value)}`;
+    case "boolean":
+      return `b:${value ? "true" : "false"}`;
+    case "bigint":
+      return `i:${String(value)}`;
+    case "symbol":
+      return `y:${String(value)}`;
+    case "function":
+      return `f:${safeString(value)}`;
+    default:
+      break;
   }
-  for (const column of columns) {
-    if (column.accessorKey || column.accessorFn || column.filterValue) {
-      values.set(columnId(column), stringifyCellValue(getFilterValue(row, column)));
-    }
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return `d:${Number.isFinite(time) ? value.toISOString() : "invalid"}`;
   }
-  return values;
+  return `o:${safeJson(value)}`;
 }
-function resolveTableSearchScopes(rows, columns, options = {}) {
-  const fields = new Set(columns.filter((c) => c.accessorKey || c.accessorFn || c.filterValue).map(columnId));
-  for (const row of rows) if (row !== null && typeof row === "object") Object.keys(row).forEach((key) => fields.add(key));
-  const roles = new Set([...fields].map((key) => options.roles?.[key] ?? inferTableSearchRole(key)));
-  const scopes = [{ id: "all", label: "All" }];
-  for (const [id, label] of [["id", "ID"], ["name", "Name"], ["description", "Description"]]) {
-    if (roles.has(id)) scopes.push({ id, label });
+function safeString(value) {
+  try {
+    return String(value);
+  } catch {
+    return "[unreadable]";
   }
-  for (const scope of options.scopes ?? []) if (!scopes.some((s) => s.id === scope.id) && scope.fields?.length) scopes.push(scope);
-  return scopes;
 }
-function rankTableSearchRows(rows, columns, query, options = {}, extraText) {
-  const q = query.trim().toLocaleLowerCase();
-  if (!q) return [...rows];
-  const scope = options.scope ?? "all";
-  const customScope = options.scopes?.find((s) => s.id === scope);
-  const mode = options.matchMode ?? "contains";
-  return rows.flatMap((row, index) => {
-    const fields = [...searchableFields(row, columns)].filter(([key]) => {
-      if (scope === "all") return true;
-      if (customScope) return customScope.fields?.includes(key) ?? false;
-      return (options.roles?.[key] ?? inferTableSearchRole(key)) === scope;
-    });
-    const extra = scope === "all" ? extraText?.(row) : void 0;
-    const texts = fields.map(([, value]) => value);
-    if (extra) texts.push(extra);
-    const matched = mode === "whole_words" ? matchesTableSearch(texts.join(" "), q, mode) : texts.some((value) => matchesTableSearch(value, q, mode));
-    if (!matched) return [];
-    let rank = 3;
-    for (const [key, value] of fields) {
-      if (!matchesTableSearch(value, q, mode)) continue;
-      const role = options.roles?.[key] ?? inferTableSearchRole(key);
-      if (role === "id" || role === "name") rank = Math.min(rank, value.trim().toLocaleLowerCase() === q ? 0 : 1);
-      else if (role === "description") rank = Math.min(rank, 2);
+function safeJson(value) {
+  try {
+    const json = JSON.stringify(value);
+    return typeof json === "string" ? json : safeString(value);
+  } catch {
+    return safeString(value);
+  }
+}
+var CURRENCY_AND_SPACE = /[\s,$£€¥]/g;
+function coerceGroupNumber(value) {
+  if (isBlankGroupValue(value)) return null;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (typeof value === "bigint") {
+    const asNumber = Number(value);
+    return Number.isFinite(asNumber) ? asNumber : null;
+  }
+  if (typeof value !== "string") return null;
+  const cleaned = value.replace(CURRENCY_AND_SPACE, "");
+  if (cleaned === "" || cleaned === "-" || cleaned === "+") return null;
+  const parsed = Number(cleaned);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+var NUMBER_FORMAT = new Intl.NumberFormat("en-US", { maximumFractionDigits: 2 });
+function formatGroupNumber(value) {
+  if (!Number.isFinite(value)) return "\u2014";
+  try {
+    return NUMBER_FORMAT.format(value);
+  } catch {
+    return String(value);
+  }
+}
+function defaultLabelOf(value, emptyLabel) {
+  if (isBlankGroupValue(value)) return emptyLabel;
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return formatGroupNumber(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return Number.isFinite(time) ? value.toISOString() : "Invalid Date";
+  }
+  if (typeof value === "object") return safeJson(value);
+  return safeString(value);
+}
+var AGGREGATE_NAMES = {
+  count: { name: "Count", position: "before" },
+  sum: { name: "Sum", position: "before" },
+  average: { name: "Average", position: "before" },
+  min: { name: "Min", position: "before" },
+  max: { name: "Max", position: "before" },
+  empty: { name: "empty", position: "after" },
+  filled: { name: "filled", position: "after" },
+  unique: { name: "unique", position: "after" },
+  checked: { name: "checked", position: "after" },
+  unchecked: { name: "unchecked", position: "after" },
+  percentFilled: { name: "filled", position: "after" }
+};
+function aggregateLabel(kind, value, override) {
+  const naming = AGGREGATE_NAMES[kind] ?? { name: kind, position: "before" };
+  const name = override && override.trim() !== "" ? override : naming.name;
+  const shown = value === null ? "\u2014" : kind === "percentFilled" ? `${formatGroupNumber(value)}%` : formatGroupNumber(value);
+  return naming.position === "before" ? `${name} ${shown}` : `${shown} ${name}`;
+}
+function readValue(row, reader) {
+  try {
+    return reader(row);
+  } catch {
+    return null;
+  }
+}
+function computeAggregate(rows, column) {
+  const kind = column.spec.kind;
+  const raw = rows.map((row) => readValue(row, column.readCell));
+  const total = raw.length;
+  const filled = raw.filter((value2) => !isBlankGroupValue(value2));
+  const numbers = filled.map((value2) => coerceGroupNumber(value2)).filter((value2) => value2 !== null);
+  let value;
+  switch (kind) {
+    case "count":
+      value = total;
+      break;
+    case "sum":
+      value = numbers.length === 0 ? null : numbers.reduce((acc, n2) => acc + n2, 0);
+      break;
+    case "average":
+      value = numbers.length === 0 ? null : numbers.reduce((acc, n2) => acc + n2, 0) / numbers.length;
+      break;
+    case "min":
+      value = numbers.length === 0 ? null : numbers.reduce((acc, n2) => n2 < acc ? n2 : acc);
+      break;
+    case "max":
+      value = numbers.length === 0 ? null : numbers.reduce((acc, n2) => n2 > acc ? n2 : acc);
+      break;
+    case "empty":
+      value = total - filled.length;
+      break;
+    case "filled":
+      value = filled.length;
+      break;
+    case "unique": {
+      const seen = /* @__PURE__ */ new Set();
+      for (const entry of filled) seen.add(groupKeyOf(entry));
+      value = seen.size;
+      break;
     }
-    return [{ row, rank, index }];
-  }).sort((a, b) => a.rank - b.rank || a.index - b.index).map((item) => item.row);
+    case "checked":
+      value = filled.filter((entry) => entry === true).length;
+      break;
+    case "unchecked":
+      value = filled.filter((entry) => entry === false).length;
+      break;
+    case "percentFilled":
+      value = total === 0 ? null : filled.length / total * 100;
+      break;
+    default:
+      value = null;
+      break;
+  }
+  return { kind, value, label: aggregateLabel(kind, value, column.spec.label) };
+}
+function compareLabels(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+function compareValues2(a, b) {
+  const aNumber = typeof a.value === "number" ? a.value : null;
+  const bNumber = typeof b.value === "number" ? b.value : null;
+  if (aNumber !== null && bNumber !== null && aNumber !== bNumber) return aNumber < bNumber ? -1 : 1;
+  if (typeof a.value === "boolean" && typeof b.value === "boolean" && a.value !== b.value) {
+    return a.value ? 1 : -1;
+  }
+  return compareLabels(a.label, b.label);
+}
+function groupRows(options) {
+  const rows = Array.isArray(options.rows) ? options.rows : [];
+  const emptyLabel = options.emptyLabel ?? DEFAULT_EMPTY_LABEL;
+  const order = options.order ?? "value-asc";
+  const aggregates = options.aggregates ?? {};
+  const labelFor = (value) => {
+    if (!options.labelOf) return defaultLabelOf(value, emptyLabel);
+    if (isBlankGroupValue(value)) {
+      try {
+        const custom = options.labelOf(value);
+        return typeof custom === "string" && custom !== "" ? custom : emptyLabel;
+      } catch {
+        return emptyLabel;
+      }
+    }
+    try {
+      const custom = options.labelOf(value);
+      return typeof custom === "string" ? custom : defaultLabelOf(value, emptyLabel);
+    } catch {
+      return defaultLabelOf(value, emptyLabel);
+    }
+  };
+  const buckets = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const raw = readValue(row, options.readCell);
+    const blank = isBlankGroupValue(raw);
+    const value = blank ? null : raw;
+    const key = groupKeyOf(value);
+    let bucket = buckets.get(key);
+    if (!bucket) {
+      bucket = { key, value, label: labelFor(value), rows: [], seen: buckets.size };
+      buckets.set(key, bucket);
+    }
+    bucket.rows.push(row);
+  }
+  const ordered = [...buckets.values()].sort((a, b) => {
+    const aBlank = a.key === EMPTY_GROUP_KEY;
+    const bBlank = b.key === EMPTY_GROUP_KEY;
+    if (aBlank !== bBlank) return aBlank ? 1 : -1;
+    if (aBlank && bBlank) return 0;
+    switch (order) {
+      case "value-asc":
+        return compareValues2(a, b) || a.seen - b.seen;
+      case "value-desc":
+        return -compareValues2(a, b) || a.seen - b.seen;
+      case "count-desc":
+        return b.rows.length - a.rows.length || a.seen - b.seen;
+      case "first-seen":
+      default:
+        return a.seen - b.seen;
+    }
+  });
+  const aggregateEntries = Object.entries(aggregates);
+  return ordered.map((bucket, index) => {
+    const results = {};
+    for (const [columnId2, column] of aggregateEntries) {
+      if (!column || typeof column.readCell !== "function" || !column.spec) continue;
+      results[columnId2] = computeAggregate(bucket.rows, column);
+    }
+    return {
+      key: bucket.key,
+      value: bucket.value,
+      label: bucket.label,
+      rows: bucket.rows,
+      aggregates: results,
+      index
+    };
+  });
+}
+function toggleGroupCollapsed(collapsed, key) {
+  const list = Array.isArray(collapsed) ? collapsed : [];
+  return list.includes(key) ? list.filter((entry) => entry !== key) : [...list, key];
+}
+function isGroupCollapsed(collapsed, key) {
+  return Array.isArray(collapsed) ? collapsed.includes(key) : false;
+}
+function flattenGroups(groups, collapsed) {
+  const out = [];
+  let dataIndex = 0;
+  for (const group of Array.isArray(groups) ? groups : []) {
+    out.push({ kind: "group", group });
+    if (isGroupCollapsed(collapsed, group.key)) continue;
+    for (const row of group.rows) {
+      out.push({ kind: "row", group, row, dataIndex });
+      dataIndex += 1;
+    }
+  }
+  return out;
+}
+function groupSummary(group, rowNoun = "row") {
+  const count = group?.rows?.length ?? 0;
+  const noun = count === 1 ? rowNoun : `${rowNoun}s`;
+  const parts = [`${formatGroupNumber(count)} ${noun}`];
+  for (const result of Object.values(group?.aggregates ?? {})) {
+    if (result?.label) parts.push(result.label);
+  }
+  return parts.join(" \xB7 ");
 }
 
-// src/data-table/ColumnManager.tsx
-import { useEffect as useEffect11, useMemo as useMemo6, useState as useState16 } from "react";
-import { useDndMonitor, useDraggable as useDraggable2, useDroppable } from "@dnd-kit/core";
-import { jsx as jsx33, jsxs as jsxs23 } from "react/jsx-runtime";
-function ColumnManager({
-  open,
-  onOpenChange,
-  columns,
-  order,
-  hidden,
-  onApply
-}) {
-  const byId = useMemo6(
-    () => new Map(columns.map((column) => [columnId(column), column])),
-    [columns]
+// src/data-table/virtual-window.ts
+var DEFAULT_OVERSCAN = 6;
+function isNum(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function toCount(value) {
+  return isNum(value) && value > 0 ? Math.floor(value) : 0;
+}
+function toLength(value) {
+  return isNum(value) && value > 0 ? value : 0;
+}
+function toOverscan(value) {
+  if (!isNum(value)) return DEFAULT_OVERSCAN;
+  return value > 0 ? Math.floor(value) : 0;
+}
+function toPinned(value, count) {
+  if (!isNum(value) || value <= 0) return 0;
+  return Math.min(Math.floor(value), count);
+}
+function assemble(args) {
+  const { pinnedCount, start, end, padStart, body, total } = args;
+  let padEnd = total - (padStart + body);
+  if (!Number.isFinite(padEnd)) padEnd = 0;
+  const sum = padStart + body + padEnd;
+  if (sum !== total) padEnd = padEnd + (total - sum);
+  const pinned = [];
+  for (let i = 0; i < pinnedCount; i += 1) pinned.push(i);
+  return { start, end, padStart, padEnd, total, pinned };
+}
+function emptyWindow(pinnedCount) {
+  const pinned = [];
+  for (let i = 0; i < pinnedCount; i += 1) pinned.push(i);
+  return { start: pinnedCount, end: pinnedCount, padStart: 0, padEnd: 0, total: 0, pinned };
+}
+function band(firstVisible, lastVisible, scrollCount, overscan) {
+  let first = firstVisible;
+  if (first > scrollCount - 1) first = scrollCount - 1;
+  if (first < 0) first = 0;
+  let last = lastVisible;
+  if (last < first + 1) last = first + 1;
+  if (last > scrollCount) last = scrollCount;
+  const start = Math.max(0, first - overscan);
+  let end = Math.min(scrollCount, last + overscan);
+  if (end < start) end = start;
+  return { start, end };
+}
+function computeWindow(input) {
+  const count = toCount(input?.count);
+  const pinnedCount = toPinned(input?.pinnedStart, count);
+  if (count <= 0) return emptyWindow(0);
+  const itemSize = toLength(input?.itemSize);
+  const viewport = toLength(input?.viewport);
+  const overscan = toOverscan(input?.overscan);
+  const scrollCount = count - pinnedCount;
+  if (scrollCount <= 0) return emptyWindow(pinnedCount);
+  if (itemSize <= 0) {
+    return assemble({ pinnedCount, start: pinnedCount, end: count, padStart: 0, body: 0, total: 0 });
+  }
+  const total = scrollCount * itemSize;
+  const maxOffset = Math.max(0, total - viewport);
+  const offset = Math.min(toLength(input?.offset), maxOffset);
+  const { start: relStart, end: relEnd } = band(
+    Math.floor(offset / itemSize),
+    Math.ceil((offset + viewport) / itemSize),
+    scrollCount,
+    overscan
   );
-  const [draftOrder, setDraftOrder] = useState16(order);
-  const [draftHidden, setDraftHidden] = useState16(() => new Set(hidden));
-  const [draggedColumnId, setDraggedColumnId] = useState16(null);
-  const [dropTarget, setDropTarget] = useState16(null);
-  useEffect11(() => {
-    if (!open) return;
-    setDraftOrder(order);
-    setDraftHidden(new Set(hidden));
-  }, [open, order, hidden]);
-  const move = (id, direction) => {
-    setDraftOrder((current) => {
-      const index = current.indexOf(id);
-      const target = index + direction;
-      if (index < 0 || target < 0 || target >= current.length) return current;
-      const next = [...current];
-      const displaced = next[target];
-      if (displaced === void 0) return current;
-      next[target] = id;
-      next[index] = displaced;
-      return next;
-    });
-  };
-  const moveTo = (id, targetId) => {
-    if (id === targetId) return;
-    setDraftOrder((current) => {
-      const from = current.indexOf(id);
-      const target = current.indexOf(targetId);
-      if (from < 0 || target < 0) return current;
-      const next = [...current];
-      next.splice(from, 1);
-      const targetAfterRemoval = next.indexOf(targetId);
-      next.splice(targetAfterRemoval, 0, id);
-      return next;
-    });
+  return assemble({
+    pinnedCount,
+    start: pinnedCount + relStart,
+    end: pinnedCount + relEnd,
+    padStart: relStart * itemSize,
+    body: (relEnd - relStart) * itemSize,
+    total
+  });
+}
+var PREFIX_CACHE = /* @__PURE__ */ new WeakMap();
+function prefixFor(sizeAt, count) {
+  let byCount = PREFIX_CACHE.get(sizeAt);
+  if (!byCount) {
+    byCount = /* @__PURE__ */ new Map();
+    PREFIX_CACHE.set(sizeAt, byCount);
+  }
+  const cached = byCount.get(count);
+  if (cached) return cached;
+  const prefix = new Float64Array(count + 1);
+  let running = 0;
+  for (let i = 0; i < count; i += 1) {
+    let size = 0;
+    try {
+      size = sizeAt(i);
+    } catch {
+      size = 0;
+    }
+    running += isNum(size) && size > 0 ? size : 0;
+    prefix[i + 1] = running;
+  }
+  byCount.set(count, prefix);
+  return prefix;
+}
+function at(prefix, index) {
+  return prefix[index] ?? 0;
+}
+function lastAtOrBefore(prefix, lo, hi, target) {
+  let a = lo;
+  let b = hi;
+  while (a < b) {
+    const mid = a + Math.ceil((b - a) / 2);
+    if (at(prefix, mid) <= target) a = mid;
+    else b = mid - 1;
+  }
+  return a;
+}
+function firstAtOrAfter(prefix, lo, hi, target) {
+  let a = lo;
+  let b = hi;
+  while (a < b) {
+    const mid = a + Math.floor((b - a) / 2);
+    if (at(prefix, mid) >= target) b = mid;
+    else a = mid + 1;
+  }
+  return a;
+}
+function computeVariableWindow(input) {
+  const count = toCount(input?.count);
+  const pinnedCount = toPinned(input?.pinnedStart, count);
+  if (count <= 0) return emptyWindow(0);
+  const sizeAt = typeof input?.sizeAt === "function" ? input.sizeAt : () => 0;
+  const viewport = toLength(input?.viewport);
+  const overscan = toOverscan(input?.overscan);
+  const scrollCount = count - pinnedCount;
+  if (scrollCount <= 0) return emptyWindow(pinnedCount);
+  const prefix = prefixFor(sizeAt, count);
+  const pinnedLength = at(prefix, pinnedCount);
+  const total = at(prefix, count) - pinnedLength;
+  if (total <= 0) {
+    return assemble({ pinnedCount, start: pinnedCount, end: count, padStart: 0, body: 0, total: total > 0 ? total : 0 });
+  }
+  const maxOffset = Math.max(0, total - viewport);
+  const offset = Math.min(toLength(input?.offset), maxOffset);
+  const firstVisible = lastAtOrBefore(prefix, pinnedCount, count, pinnedLength + offset) - pinnedCount;
+  const lastVisible = firstAtOrAfter(prefix, pinnedCount, count, pinnedLength + offset + viewport) - pinnedCount;
+  const { start: relStart, end: relEnd } = band(firstVisible, lastVisible, scrollCount, overscan);
+  const absStart = pinnedCount + relStart;
+  const absEnd = pinnedCount + relEnd;
+  return assemble({
+    pinnedCount,
+    start: absStart,
+    end: absEnd,
+    padStart: at(prefix, absStart) - pinnedLength,
+    body: at(prefix, absEnd) - at(prefix, absStart),
+    total
+  });
+}
+function scrollOffsetForIndex(input) {
+  const count = toCount(input?.count);
+  if (count <= 0) return null;
+  const pinnedCount = toPinned(input?.pinnedStart, count);
+  const itemSize = toLength(input?.itemSize);
+  const viewport = toLength(input?.viewport);
+  const scrollCount = count - pinnedCount;
+  if (scrollCount <= 0 || itemSize <= 0) return null;
+  const rawIndex = isNum(input?.index) ? Math.floor(input.index) : 0;
+  const index = Math.min(Math.max(rawIndex, 0), count - 1);
+  if (index < pinnedCount) return null;
+  const total = scrollCount * itemSize;
+  const maxOffset = Math.max(0, total - viewport);
+  const offset = Math.min(toLength(input?.offset), maxOffset);
+  const itemStart = (index - pinnedCount) * itemSize;
+  const itemEnd = itemStart + itemSize;
+  if (itemStart >= offset && itemEnd <= offset + viewport) return null;
+  const next = itemStart < offset ? itemStart : itemEnd - viewport;
+  const clamped = Math.min(Math.max(next, 0), maxOffset);
+  return clamped === offset ? null : clamped;
+}
+
+// src/data-table/useSpreadsheetGrid.ts
+import { useCallback as useCallback7, useEffect as useEffect11, useMemo as useMemo6, useRef as useRef12, useState as useState16 } from "react";
+
+// src/data-table/grid-selection.ts
+function rangeBounds(range, rowIds, fieldNames) {
+  const ra = rowIds.indexOf(range.anchor.rowId);
+  const rf = rowIds.indexOf(range.focus.rowId);
+  const ca = fieldNames.indexOf(range.anchor.fieldName);
+  const cf = fieldNames.indexOf(range.focus.fieldName);
+  if (ra === -1 || rf === -1 || ca === -1 || cf === -1) return null;
+  return {
+    r0: Math.min(ra, rf),
+    r1: Math.max(ra, rf),
+    c0: Math.min(ca, cf),
+    c1: Math.max(ca, cf)
+  };
+}
+function rangeSize(bounds) {
+  const rows = bounds.r1 - bounds.r0 + 1;
+  const cols = bounds.c1 - bounds.c0 + 1;
+  return { rows, cols, cells: rows * cols };
+}
+function boundsContain(bounds, rowIndex, colIndex) {
+  return rowIndex >= bounds.r0 && rowIndex <= bounds.r1 && colIndex >= bounds.c0 && colIndex <= bounds.c1;
+}
+function cellsInRange(range, rowIds, fieldNames) {
+  const b = rangeBounds(range, rowIds, fieldNames);
+  if (!b) return [];
+  const out = [];
+  for (let r = b.r0; r <= b.r1; r += 1) {
+    const rowId = rowIds[r];
+    if (rowId === void 0) continue;
+    for (let c = b.c0; c <= b.c1; c += 1) {
+      const fieldName = fieldNames[c];
+      if (fieldName === void 0) continue;
+      out.push({ rowId, fieldName });
+    }
+  }
+  return out;
+}
+function rangeRows(range, rowIds, fieldNames) {
+  const b = rangeBounds(range, rowIds, fieldNames);
+  if (!b) return [];
+  const rows = [];
+  for (let r = b.r0; r <= b.r1; r += 1) {
+    const rowId = rowIds[r];
+    if (rowId === void 0) continue;
+    const row = [];
+    for (let c = b.c0; c <= b.c1; c += 1) {
+      const fieldName = fieldNames[c];
+      if (fieldName === void 0) continue;
+      row.push({ rowId, fieldName });
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+function isSingleCellRange(range) {
+  return sameCell(range.anchor, range.focus);
+}
+function rowRange(rowId, fieldNames) {
+  const firstField = fieldNames[0];
+  const lastField = fieldNames[fieldNames.length - 1];
+  if (firstField === void 0 || lastField === void 0) return null;
+  return {
+    anchor: { rowId, fieldName: firstField },
+    focus: { rowId, fieldName: lastField }
+  };
+}
+function columnRange(fieldName, rowIds) {
+  const firstRow = rowIds[0];
+  const lastRow = rowIds[rowIds.length - 1];
+  if (firstRow === void 0 || lastRow === void 0) return null;
+  return {
+    anchor: { rowId: firstRow, fieldName },
+    focus: { rowId: lastRow, fieldName }
+  };
+}
+function allRange(rowIds, fieldNames) {
+  const firstRow = rowIds[0];
+  const lastRow = rowIds[rowIds.length - 1];
+  const firstField = fieldNames[0];
+  const lastField = fieldNames[fieldNames.length - 1];
+  if (firstRow === void 0 || lastRow === void 0 || firstField === void 0 || lastField === void 0) {
+    return null;
+  }
+  return {
+    anchor: { rowId: firstRow, fieldName: firstField },
+    focus: { rowId: lastRow, fieldName: lastField }
+  };
+}
+function sameCell(a, b) {
+  if (!a || !b) return a === b;
+  return a.rowId === b.rowId && a.fieldName === b.fieldName;
+}
+function moveSelection(current, move, rowIds, fieldNames) {
+  if (rowIds.length === 0 || fieldNames.length === 0) return null;
+  const firstRowId = rowIds[0];
+  const firstFieldName = fieldNames[0];
+  if (firstRowId === void 0 || firstFieldName === void 0) return null;
+  const first = { rowId: firstRowId, fieldName: firstFieldName };
+  if (!current) return first;
+  let r = rowIds.indexOf(current.rowId);
+  let c = fieldNames.indexOf(current.fieldName);
+  if (r === -1 || c === -1) return first;
+  const lastRow = rowIds.length - 1;
+  const lastCol = fieldNames.length - 1;
+  const clamp = (n2, max) => Math.min(Math.max(n2, 0), max);
+  switch (move) {
+    case "up":
+      r = clamp(r - 1, lastRow);
+      break;
+    case "down":
+      r = clamp(r + 1, lastRow);
+      break;
+    case "left":
+      c = clamp(c - 1, lastCol);
+      break;
+    case "right":
+      c = clamp(c + 1, lastCol);
+      break;
+    case "rowStart":
+      c = 0;
+      break;
+    case "rowEnd":
+      c = lastCol;
+      break;
+    case "gridStart":
+      r = 0;
+      c = 0;
+      break;
+    case "gridEnd":
+      r = lastRow;
+      c = lastCol;
+      break;
+    case "nextCell":
+      if (c < lastCol) c += 1;
+      else if (r < lastRow) {
+        r += 1;
+        c = 0;
+      }
+      break;
+    case "prevCell":
+      if (c > 0) c -= 1;
+      else if (r > 0) {
+        r -= 1;
+        c = lastCol;
+      }
+      break;
+  }
+  const rowId = rowIds[r];
+  const fieldName = fieldNames[c];
+  if (rowId === void 0 || fieldName === void 0) return first;
+  return { rowId, fieldName };
+}
+function isTypingKey(e) {
+  if (e.ctrlKey || e.metaKey || e.altKey) return false;
+  return e.key.length === 1 && e.key !== " ";
+}
+function classifyGridKey(e) {
+  const mod = e.ctrlKey || e.metaKey;
+  const arrowMove = {
+    ArrowUp: mod ? "gridStart" : "up",
+    ArrowDown: mod ? "gridEnd" : "down",
+    ArrowLeft: mod ? "rowStart" : "left",
+    ArrowRight: mod ? "rowEnd" : "right",
+    Home: mod ? "gridStart" : "rowStart",
+    End: mod ? "gridEnd" : "rowEnd"
+  };
+  const arrow = arrowMove[e.key];
+  if (arrow !== void 0) {
+    return { kind: e.shiftKey ? "extend" : "move", move: arrow };
+  }
+  switch (e.key) {
+    case "Tab":
+      return { kind: "move", move: e.shiftKey ? "prevCell" : "nextCell" };
+    case "Enter":
+    case "F2":
+      return { kind: "edit" };
+    case " ":
+      if (e.shiftKey) return { kind: "selectRow" };
+      if (mod) return { kind: "selectColumn" };
+      return { kind: "edit" };
+    case "a":
+    case "A":
+      if (mod) return { kind: "selectAll" };
+      break;
+    case "d":
+    case "D":
+      if (mod) return { kind: "fillDown" };
+      break;
+    case "Escape":
+      return { kind: "escape" };
+    case "Delete":
+    case "Backspace":
+      return { kind: "clearCell" };
+    case "c":
+    case "C":
+      if (mod) return { kind: "copy" };
+      break;
+    case "x":
+    case "X":
+      if (mod) return { kind: "cut" };
+      break;
+    case "v":
+    case "V":
+      if (mod) return { kind: "paste" };
+      break;
+  }
+  if (isTypingKey(e)) return { kind: "editSeeded", seed: e.key };
+  return null;
+}
+function directClickKinds() {
+  return ["checkbox", "rating", "select", "multiselect"];
+}
+function isDirectClickEditor(editorKind) {
+  return editorKind !== void 0 && directClickKinds().includes(editorKind);
+}
+function cellDomKey(address) {
+  return `${address.rowId}::${address.fieldName}`;
+}
+
+// src/data-table/grid-clipboard.ts
+function cellClipboardText(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function tsvCell(text) {
+  return /[\t\r\n"]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function gridToTsv(block) {
+  return block.map((row) => row.map((cell) => tsvCell(cellClipboardText(cell))).join("	")).join("\n");
+}
+function parseClipboardGrid(text) {
+  const rows = [];
+  let row = [];
+  let cell = "";
+  let i = 0;
+  const n2 = text.length;
+  while (i < n2) {
+    const ch = text[i];
+    if (cell === "" && ch === '"') {
+      let j = i + 1;
+      let out = "";
+      let closed = false;
+      while (j < n2) {
+        const c = text[j];
+        if (c === '"') {
+          if (text[j + 1] === '"') {
+            out += '"';
+            j += 2;
+            continue;
+          }
+          closed = true;
+          j += 1;
+          break;
+        }
+        out += c;
+        j += 1;
+      }
+      if (closed && (j >= n2 || text[j] === "	" || text[j] === "\n" || text[j] === "\r")) {
+        cell = out;
+        i = j;
+        if (i >= n2) break;
+        const d = text[i];
+        if (d === "	") {
+          row.push(cell);
+          cell = "";
+          i += 1;
+          continue;
+        }
+        row.push(cell);
+        rows.push(row);
+        row = [];
+        cell = "";
+        i += d === "\r" && text[i + 1] === "\n" ? 2 : 1;
+        continue;
+      }
+      cell += ch;
+      i += 1;
+      continue;
+    }
+    if (ch === "	") {
+      row.push(cell);
+      cell = "";
+      i += 1;
+      continue;
+    }
+    if (ch === "\n" || ch === "\r") {
+      row.push(cell);
+      rows.push(row);
+      row = [];
+      cell = "";
+      i += ch === "\r" && text[i + 1] === "\n" ? 2 : 1;
+      continue;
+    }
+    cell += ch;
+    i += 1;
+  }
+  const endedOnBreak = n2 > 0 && (text[n2 - 1] === "\n" || text[n2 - 1] === "\r");
+  if (!endedOnBreak) {
+    row.push(cell);
+    rows.push(row);
+  } else if (row.length > 0) {
+    row.push(cell);
+    rows.push(row);
+  }
+  return rows.length === 0 ? [[""]] : rows;
+}
+function planPaste(anchor, block, rowIds, fieldNames) {
+  const r0 = rowIds.indexOf(anchor.rowId);
+  const c0 = fieldNames.indexOf(anchor.fieldName);
+  if (r0 === -1 || c0 === -1) return null;
+  const width = block.reduce((w, row) => Math.max(w, row.length), 0);
+  const colsAvailable = fieldNames.length - c0;
+  const colsUsed = Math.min(width, colsAvailable);
+  const targetFields = fieldNames.slice(c0, c0 + colsUsed);
+  const cells = [];
+  const overflowRows = [];
+  block.forEach((blockRow, dr) => {
+    const rowId = rowIds[r0 + dr];
+    if (rowId === void 0) {
+      overflowRows.push(targetFields.map((_, dc) => blockRow[dc] ?? ""));
+      return;
+    }
+    targetFields.forEach((fieldName, dc) => {
+      if (dc >= blockRow.length) return;
+      const raw = blockRow[dc];
+      if (raw === void 0) return;
+      cells.push({ rowId, fieldName, raw });
+    });
+  });
+  return {
+    cells,
+    overflowRows,
+    clippedColumns: Math.max(0, width - colsAvailable),
+    fieldNames: targetFields
+  };
+}
+function isSingleCell(block) {
+  return block.length === 1 && block[0]?.length === 1;
+}
+function storedValuesEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || a === void 0 || b === void 0) {
+    return (a ?? null) === (b ?? null);
+  }
+  if (typeof a === "object" || typeof b === "object") {
+    try {
+      return JSON.stringify(a) === JSON.stringify(b);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+// src/data-table/fill.ts
+var NO_SERIES = { kind: "none", step: 0 };
+var MS_PER_DAY = 864e5;
+function plural(count, one, many) {
+  return `${count} ${count === 1 ? one : many}`;
+}
+function isValidRect(rect) {
+  return Number.isInteger(rect.top) && Number.isInteger(rect.left) && Number.isInteger(rect.bottom) && Number.isInteger(rect.right) && rect.top <= rect.bottom && rect.left <= rect.right;
+}
+function asBounds(rect) {
+  return { r0: rect.top, r1: rect.bottom, c0: rect.left, c1: rect.right };
+}
+function directionOf(source, target) {
+  if (!isValidRect(source) || !isValidRect(target)) return null;
+  if (target.top === source.bottom + 1) return "down";
+  if (target.bottom === source.top - 1) return "up";
+  if (target.left === source.right + 1) return "right";
+  if (target.right === source.left - 1) return "left";
+  return null;
+}
+function tileIndex(i, a, b) {
+  const n2 = b - a + 1;
+  if (n2 <= 0) return a;
+  if (i >= a && i <= b) return i;
+  if (i > b) return a + (i - a) % n2;
+  return b - (a - 1 - i) % n2;
+}
+function isFiniteNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+var DATE_ISH = /^\d{4}-\d{2}-\d{2}([T ]|$)/;
+function dateMs(v) {
+  if (v instanceof Date) {
+    const t = v.getTime();
+    return Number.isFinite(t) ? t : null;
+  }
+  if (typeof v === "string" && DATE_ISH.test(v)) {
+    const t = Date.parse(v);
+    return Number.isFinite(t) ? t : null;
+  }
+  return null;
+}
+function detectSeries(values) {
+  if (!Array.isArray(values) || values.length < 2) return NO_SERIES;
+  if (values.every(isFiniteNumber)) {
+    const nums = values;
+    const first = nums[0];
+    const second = nums[1];
+    if (first === void 0 || second === void 0) return NO_SERIES;
+    const step = second - first;
+    for (let i = 1; i < nums.length; i += 1) {
+      const prev = nums[i - 1];
+      const cur = nums[i];
+      if (prev === void 0 || cur === void 0) return NO_SERIES;
+      if (cur - prev !== step) return NO_SERIES;
+    }
+    return { kind: "number", step };
+  }
+  const stamps = values.map(dateMs);
+  if (stamps.every((t) => t !== null)) {
+    const first = stamps[0];
+    const second = stamps[1];
+    if (first === void 0 || second === void 0) return NO_SERIES;
+    const deltaMs = second - first;
+    if (deltaMs % MS_PER_DAY !== 0) return NO_SERIES;
+    for (let i = 1; i < stamps.length; i += 1) {
+      const prev = stamps[i - 1];
+      const cur = stamps[i];
+      if (prev === void 0 || cur === void 0) return NO_SERIES;
+      if (cur - prev !== deltaMs) return NO_SERIES;
+    }
+    return { kind: "date", step: deltaMs / MS_PER_DAY };
+  }
+  return NO_SERIES;
+}
+function formatDateLike(ms, sample) {
+  const iso = new Date(ms).toISOString();
+  if (typeof sample === "string" && DATE_ONLY.test(sample)) return iso.slice(0, 10);
+  return iso;
+}
+function extrapolate(line, series, k) {
+  const last = line[line.length - 1];
+  if (series.kind === "number" && isFiniteNumber(last)) {
+    return last + k * series.step;
+  }
+  if (series.kind === "date") {
+    const base = dateMs(last);
+    if (base === null) return jsonable(last);
+    return formatDateLike(base + k * series.step * MS_PER_DAY, last);
+  }
+  return jsonable(last);
+}
+function jsonable(value) {
+  if (value instanceof Date) {
+    const t = value.getTime();
+    return Number.isFinite(t) ? value.toISOString() : null;
+  }
+  if (value === void 0) return null;
+  return value;
+}
+function emptyResult(summary) {
+  return { patches: [], skipped: [], summary };
+}
+function fillRange(request) {
+  const { source, target, columnIds, rowIds } = request;
+  const mode = request.mode ?? "series";
+  const isWritable = request.isColumnWritable ?? (() => true);
+  const direction = directionOf(source, target);
+  if (!direction) {
+    return emptyResult(
+      "Filled 0 cells because the fill area does not touch the selection."
+    );
+  }
+  if (rowIds.length === 0 || columnIds.length === 0) {
+    return emptyResult("Filled 0 cells because the table is empty.");
+  }
+  const read = (r, c) => {
+    try {
+      return { ok: true, value: request.valueAt(r, c) };
+    } catch {
+      return { ok: false, value: void 0 };
+    }
+  };
+  const vertical = direction === "down" || direction === "up";
+  const forward = direction === "down" || direction === "right";
+  const fillStart = vertical ? source.top : source.left;
+  const fillEnd = vertical ? source.bottom : source.right;
+  const crossStart = vertical ? source.left : source.top;
+  const crossEnd = vertical ? source.right : source.bottom;
+  const maxFill = (vertical ? rowIds.length : columnIds.length) - 1;
+  const maxCross = (vertical ? columnIds.length : rowIds.length) - 1;
+  const rawFillFrom = vertical ? target.top : target.left;
+  const rawFillTo = vertical ? target.bottom : target.right;
+  const rawCrossFrom = vertical ? target.left : target.top;
+  const rawCrossTo = vertical ? target.right : target.bottom;
+  const fillFrom = Math.max(rawFillFrom, 0);
+  const fillTo = Math.min(rawFillTo, maxFill);
+  const crossFrom = Math.max(rawCrossFrom, 0);
+  const crossTo = Math.min(rawCrossTo, maxCross);
+  const requested = Math.max(rawFillTo - rawFillFrom + 1, 0) * Math.max(rawCrossTo - rawCrossFrom + 1, 0);
+  const inside = Math.max(fillTo - fillFrom + 1, 0) * Math.max(crossTo - crossFrom + 1, 0);
+  const outside = Math.max(requested - inside, 0);
+  const sourceBounds = asBounds(source);
+  const patches = [];
+  const skipped = [];
+  const touchedColumns = /* @__PURE__ */ new Set();
+  const lines = /* @__PURE__ */ new Map();
+  const lineFor = (crossIndex) => {
+    const srcCross = tileIndex(crossIndex, crossStart, crossEnd);
+    const cached = lines.get(srcCross);
+    if (cached) return cached;
+    const values = [];
+    const reads = [];
+    for (let f = fillStart; f <= fillEnd; f += 1) {
+      const r = vertical ? f : srcCross;
+      const c = vertical ? srcCross : f;
+      const got = read(r, c);
+      values.push(got.value);
+      reads.push(got.ok);
+    }
+    const series = mode === "series" ? detectSeries(values) : NO_SERIES;
+    const line = { values, reads, series };
+    lines.set(srcCross, line);
+    return line;
+  };
+  for (let f = fillFrom; f <= fillTo; f += 1) {
+    for (let x = crossFrom; x <= crossTo; x += 1) {
+      const rowIndex = vertical ? f : x;
+      const colIndex = vertical ? x : f;
+      const rowId = rowIds[rowIndex];
+      const columnId2 = columnIds[colIndex];
+      if (rowId === void 0 || columnId2 === void 0) continue;
+      if (boundsContain(sourceBounds, rowIndex, colIndex)) continue;
+      if (!isWritable(columnId2)) {
+        skipped.push({
+          rowId,
+          columnId: columnId2,
+          reason: `${columnId2} cannot be filled because that column is read-only.`
+        });
+        continue;
+      }
+      const line = lineFor(x);
+      if (line.series.kind !== "none") {
+        const k = forward ? f - fillEnd : fillStart - f;
+        patches.push({ rowId, columnId: columnId2, value: jsonable(extrapolate(line.values, line.series, k)) });
+        touchedColumns.add(columnId2);
+        continue;
+      }
+      const srcFill = tileIndex(f, fillStart, fillEnd);
+      const patternIndex = srcFill - fillStart;
+      if (line.reads[patternIndex] !== true) {
+        skipped.push({
+          rowId,
+          columnId: columnId2,
+          reason: `The value to copy into ${columnId2} could not be read, so that cell was left alone.`
+        });
+        continue;
+      }
+      patches.push({ rowId, columnId: columnId2, value: jsonable(line.values[patternIndex]) });
+      touchedColumns.add(columnId2);
+    }
+  }
+  return { patches, skipped, summary: summarize(direction, patches, skipped, touchedColumns, outside) };
+}
+function summarize(direction, patches, skipped, touchedColumns, outside) {
+  const parts = [];
+  if (patches.length === 0) {
+    parts.push("Filled 0 cells because there was nothing to fill.");
+  } else if (direction === "down" || direction === "up") {
+    const word = direction === "down" ? "down" : "up";
+    parts.push(
+      `Filled ${plural(patches.length, "cell", "cells")} ${word} ${plural(touchedColumns.size, "column", "columns")}.`
+    );
+  } else {
+    const word = direction === "right" ? "right" : "left";
+    parts.push(
+      `Filled ${plural(patches.length, "cell", "cells")} ${word} across ${plural(touchedColumns.size, "column", "columns")}.`
+    );
+  }
+  if (skipped.length > 0) {
+    parts.push(`Skipped ${plural(skipped.length, "cell", "cells")} that could not be filled.`);
+  }
+  if (outside > 0) {
+    parts.push(`Ignored ${plural(outside, "cell", "cells")} outside the table.`);
+  }
+  return parts.join(" ");
+}
+function fillDown(request) {
+  const { range, ...rest } = request;
+  if (!isValidRect(range)) {
+    return emptyResult("Filled 0 cells because the selection is not a rectangle.");
+  }
+  if (range.top === range.bottom) {
+    return emptyResult("Filled 0 cells because the selection is a single row.");
+  }
+  return fillRange({
+    ...rest,
+    source: { top: range.top, left: range.left, bottom: range.top, right: range.right },
+    target: { top: range.top + 1, left: range.left, bottom: range.bottom, right: range.right }
+  });
+}
+function fillTargetFor(source, toRow, toColumn) {
+  if (!isValidRect(source)) return null;
+  if (!Number.isInteger(toRow) || !Number.isInteger(toColumn)) return null;
+  const below = toRow - source.bottom;
+  const above = source.top - toRow;
+  const rightOf = toColumn - source.right;
+  const leftOf = source.left - toColumn;
+  const vertical = Math.max(below, above, 0);
+  const horizontal = Math.max(rightOf, leftOf, 0);
+  if (vertical === 0 && horizontal === 0) return null;
+  if (vertical >= horizontal) {
+    if (below > 0) {
+      return { top: source.bottom + 1, bottom: toRow, left: source.left, right: source.right };
+    }
+    return { top: toRow, bottom: source.top - 1, left: source.left, right: source.right };
+  }
+  if (rightOf > 0) {
+    return { top: source.top, bottom: source.bottom, left: source.right + 1, right: toColumn };
+  }
+  return { top: source.top, bottom: source.bottom, left: toColumn, right: source.left - 1 };
+}
+
+// src/data-table/cell-undo.ts
+var DEFAULT_UNDO_DEPTH = 100;
+function createUndoStack(depth = DEFAULT_UNDO_DEPTH) {
+  const bounded = Number.isFinite(depth) && depth > 0 ? Math.floor(depth) : 0;
+  return { past: [], future: [], depth: bounded };
+}
+function pushUndo(stack, entry) {
+  if (stack.depth <= 0) {
+    return { past: [], future: [], depth: stack.depth };
+  }
+  const past = [...stack.past, entry];
+  while (past.length > stack.depth) past.shift();
+  return { past, future: [], depth: stack.depth };
+}
+function popUndo(stack) {
+  const entry = stack.past[stack.past.length - 1];
+  if (entry === void 0) return { stack, entry: null };
+  return {
+    stack: {
+      past: stack.past.slice(0, -1),
+      future: [...stack.future, entry],
+      depth: stack.depth
+    },
+    entry
+  };
+}
+function popRedo(stack) {
+  const entry = stack.future[stack.future.length - 1];
+  if (entry === void 0) return { stack, entry: null };
+  const past = [...stack.past, entry];
+  while (past.length > stack.depth) past.shift();
+  return {
+    stack: { past, future: stack.future.slice(0, -1), depth: stack.depth },
+    entry
+  };
+}
+function keyOf(patch) {
+  return JSON.stringify([patch.rowId, patch.columnId]);
+}
+function undoEntryFor(before, after, label) {
+  const priors = /* @__PURE__ */ new Map();
+  for (const patch of before) priors.set(keyOf(patch), patch);
+  const undo = after.map((patch) => {
+    const prior = priors.get(keyOf(patch));
+    return {
+      rowId: patch.rowId,
+      columnId: patch.columnId,
+      value: prior ? prior.value : null
+    };
+  });
+  return {
+    label,
+    undo,
+    redo: after.map((patch) => ({
+      rowId: patch.rowId,
+      columnId: patch.columnId,
+      value: patch.value
+    }))
+  };
+}
+function canUndo(stack) {
+  return stack.depth > 0 && stack.past.length > 0;
+}
+function canRedo(stack) {
+  return stack.depth > 0 && stack.future.length > 0;
+}
+
+// src/data-table/useSpreadsheetGrid.ts
+function targetsAnEditor(target) {
+  const element = target instanceof Element ? target : null;
+  if (!element) return false;
+  return element.closest("input, textarea, select, [contenteditable='true']") !== null;
+}
+function useSpreadsheetGrid(options) {
+  const [range, setRange] = useState16(null);
+  const [fillTarget, setFillTarget] = useState16(null);
+  const [stack, setStack] = useState16(() => createUndoStack(options?.undoDepth ?? 100));
+  const draggingRef = useRef12(null);
+  const optionsRef = useRef12(options);
+  optionsRef.current = options;
+  const rowIds = options?.rowIds ?? [];
+  const columnIds = useMemo6(
+    () => options ? options.columnIds.filter((id) => id !== "") : [],
+    [options]
+  );
+  useEffect11(() => {
+    if (!range) return;
+    const rowSet = new Set(rowIds);
+    const colSet = new Set(columnIds);
+    const alive = rowSet.has(range.anchor.rowId) && rowSet.has(range.focus.rowId) && colSet.has(range.anchor.fieldName) && colSet.has(range.focus.fieldName);
+    if (!alive) setRange(null);
+  }, [range, rowIds, columnIds]);
+  const bounds = useMemo6(
+    () => range ? rangeBounds(range, rowIds, columnIds) : null,
+    [range, rowIds, columnIds]
+  );
+  const rowIndexById = useMemo6(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < rowIds.length; i += 1) map.set(rowIds[i], i);
+    return map;
+  }, [rowIds]);
+  const columnIndexById = useMemo6(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < columnIds.length; i += 1) map.set(columnIds[i], i);
+    return map;
+  }, [columnIds]);
+  const screenPatches = useCallback7(
+    (patches) => {
+      const validate = optionsRef.current?.validateCell;
+      if (!validate) return { accepted: patches, refusals: [] };
+      const accepted = [];
+      const refusals = [];
+      for (const patch of patches) {
+        let reason;
+        try {
+          reason = validate({ rowId: patch.rowId, columnId: patch.columnId, value: patch.value });
+        } catch {
+          reason = void 0;
+        }
+        if (reason) refusals.push({ columnId: patch.columnId, reason });
+        else accepted.push(patch);
+      }
+      return { accepted, refusals };
+    },
+    []
+  );
+  const applyPatches = useCallback7(
+    async (patches, intent, label) => {
+      const current = optionsRef.current;
+      if (!current || patches.length === 0) return;
+      const depth = current.undoDepth ?? 100;
+      if (depth > 0 && intent !== "undo" && intent !== "redo") {
+        const before = patches.map((patch) => ({
+          rowId: patch.rowId,
+          columnId: patch.columnId,
+          value: current.valueAt(patch.rowId, patch.columnId) ?? null
+        }));
+        setStack((previous) => pushUndo(previous, undoEntryFor(before, patches, label)));
+      }
+      await current.onPatch(patches, intent);
+    },
+    []
+  );
+  const readValueAt = useCallback7((rowIndex, columnIndex) => {
+    const current = optionsRef.current;
+    const rowId = current?.rowIds[rowIndex];
+    const columnId2 = current?.columnIds[columnIndex];
+    if (!current || rowId === void 0 || columnId2 === void 0) return null;
+    return current.valueAt(rowId, columnId2);
+  }, []);
+  const fillRequestBase = useCallback7(() => {
+    const current = optionsRef.current;
+    if (!current) return null;
+    return {
+      valueAt: readValueAt,
+      columnIds: [...current.columnIds],
+      rowIds: [...current.rowIds],
+      isColumnWritable: current.isColumnWritable
+    };
+  }, [readValueAt]);
+  const announceSkips = useCallback7(
+    (skipped, summary) => {
+      const current = optionsRef.current;
+      if (!current?.notify) return;
+      if (skipped.length === 0) {
+        current.notify(summary);
+        return;
+      }
+      const first = skipped[0];
+      const reason = current.columnRefusal?.(first.columnId) ?? first.reason;
+      const rest = skipped.length > 1 ? ` ${skipped.length - 1} more were left alone.` : "";
+      current.notify(`${summary} ${reason}${rest}`);
+    },
+    []
+  );
+  const doFillDown = useCallback7(async () => {
+    const base = fillRequestBase();
+    if (!base || !bounds) return;
+    const result = fillDown({
+      ...base,
+      range: { top: bounds.r0, left: bounds.c0, bottom: bounds.r1, right: bounds.c1 }
+    });
+    const screened = screenPatches(result.patches);
+    await applyPatches(screened.accepted, "fill-down", "Filled down");
+    announceSkips([...result.skipped, ...screened.refusals], result.summary);
+  }, [fillRequestBase, bounds, applyPatches, announceSkips, screenPatches]);
+  const doClear = useCallback7(async () => {
+    const current = optionsRef.current;
+    if (!current || !bounds) return;
+    const patches = [];
+    const skipped = [];
+    for (let r = bounds.r0; r <= bounds.r1; r += 1) {
+      for (let c = bounds.c0; c <= bounds.c1; c += 1) {
+        const rowId = current.rowIds[r];
+        const columnId2 = current.columnIds[c];
+        if (rowId === void 0 || columnId2 === void 0) continue;
+        if (!current.isColumnWritable(columnId2)) {
+          skipped.push({
+            columnId: columnId2,
+            reason: current.columnRefusal?.(columnId2) ?? `${columnId2} cannot be cleared.`
+          });
+          continue;
+        }
+        patches.push({ rowId, columnId: columnId2, value: null });
+      }
+    }
+    const screened = screenPatches(patches);
+    await applyPatches(screened.accepted, "clear", "Cleared");
+    announceSkips(
+      [...skipped, ...screened.refusals],
+      `Cleared ${screened.accepted.length} cells.`
+    );
+  }, [bounds, applyPatches, announceSkips, screenPatches]);
+  const doUndo = useCallback7(async () => {
+    const taken = popUndo(stack);
+    if (!taken.entry) return;
+    setStack(taken.stack);
+    await applyPatches(taken.entry.undo, "undo", taken.entry.label);
+    optionsRef.current?.notify?.(taken.entry.label);
+  }, [stack, applyPatches]);
+  const doRedo = useCallback7(async () => {
+    const taken = popRedo(stack);
+    if (!taken.entry) return;
+    setStack(taken.stack);
+    await applyPatches(taken.entry.redo, "redo", taken.entry.label);
+  }, [stack, applyPatches]);
+  const move = useCallback7(
+    (direction, extend) => {
+      setRange((previous) => {
+        const from = previous ? previous.focus : null;
+        const next = moveSelection(from, direction, rowIds, columnIds);
+        if (!next) return previous;
+        if (extend && previous) return { anchor: previous.anchor, focus: next };
+        return { anchor: next, focus: next };
+      });
+    },
+    [rowIds, columnIds]
+  );
+  const onKeyDown = useCallback7(
+    (event) => {
+      const current = optionsRef.current;
+      if (!current) return;
+      if (targetsAnEditor(event.target)) return;
+      const accel = event.metaKey || event.ctrlKey;
+      if (accel && (event.key === "z" || event.key === "Z")) {
+        event.preventDefault();
+        if (event.shiftKey) void doRedo();
+        else void doUndo();
+        return;
+      }
+      if (accel && (event.key === "y" || event.key === "Y")) {
+        event.preventDefault();
+        void doRedo();
+        return;
+      }
+      const action = classifyGridKey(event);
+      if (!action) return;
+      switch (action.kind) {
+        case "move":
+          event.preventDefault();
+          move(action.move, false);
+          return;
+        case "extend":
+          event.preventDefault();
+          move(action.move, true);
+          return;
+        case "selectAll": {
+          event.preventDefault();
+          const all = allRange(rowIds, columnIds);
+          if (all) setRange(all);
+          return;
+        }
+        case "selectRow": {
+          event.preventDefault();
+          const focused = range?.focus;
+          const next = focused ? rowRange(focused.rowId, columnIds) : null;
+          if (next) setRange(next);
+          return;
+        }
+        case "selectColumn": {
+          event.preventDefault();
+          const focused = range?.focus;
+          const next = focused ? columnRange(focused.fieldName, rowIds) : null;
+          if (next) setRange(next);
+          return;
+        }
+        case "clearCell":
+          event.preventDefault();
+          void doClear();
+          return;
+        case "fillDown":
+          event.preventDefault();
+          void doFillDown();
+          return;
+        case "escape":
+          setRange(null);
+          return;
+        case "edit":
+        case "editSeeded": {
+          const focused = range?.focus;
+          if (!focused || !current.onEditRequest) return;
+          const seed = action.kind === "editSeeded" ? action.seed : null;
+          if (current.onEditRequest(focused, seed)) event.preventDefault();
+          return;
+        }
+        default:
+          return;
+      }
+    },
+    [move, range, rowIds, columnIds, doClear, doFillDown, doUndo, doRedo]
+  );
+  const selectionAsTsv = useCallback7(() => {
+    const current = optionsRef.current;
+    if (!current || !range) return "";
+    const grid = rangeRows(range, rowIds, columnIds).map(
+      (row) => row.map((address) => current.valueAt(address.rowId, address.fieldName))
+    );
+    return gridToTsv(grid);
+  }, [range, rowIds, columnIds]);
+  const selectionAddresses = useCallback7(() => {
+    if (!range || !bounds) return { rowIds: [], columnIds: [] };
+    return {
+      rowIds: rowIds.slice(bounds.r0, bounds.r1 + 1),
+      columnIds: columnIds.slice(bounds.c0, bounds.c1 + 1)
+    };
+  }, [range, bounds, rowIds, columnIds]);
+  const onCopy = useCallback7(
+    (event) => {
+      if (!optionsRef.current || !range || targetsAnEditor(event.target)) return;
+      const text = selectionAsTsv();
+      if (!text) return;
+      event.preventDefault();
+      event.clipboardData?.setData("text/plain", text);
+    },
+    [range, selectionAsTsv]
+  );
+  const onCut = useCallback7(
+    (event) => {
+      if (!optionsRef.current || !range || targetsAnEditor(event.target)) return;
+      const text = selectionAsTsv();
+      if (!text) return;
+      event.preventDefault();
+      event.clipboardData?.setData("text/plain", text);
+      void doClear();
+    },
+    [range, selectionAsTsv, doClear]
+  );
+  const onPaste = useCallback7(
+    (event) => {
+      const current = optionsRef.current;
+      if (!current || current.paste === false || !range || targetsAnEditor(event.target)) return;
+      const text = event.clipboardData?.getData("text/plain") ?? "";
+      if (!text) return;
+      event.preventDefault();
+      const block = parseClipboardGrid(text);
+      const start = range.focus;
+      const startRow = rowIds.indexOf(start.rowId);
+      const startCol = columnIds.indexOf(start.fieldName);
+      if (startRow === -1 || startCol === -1) return;
+      const patches = [];
+      const skipped = [];
+      let outside = 0;
+      for (let r = 0; r < block.length; r += 1) {
+        const line = block[r] ?? [];
+        for (let c = 0; c < line.length; c += 1) {
+          const rowId = rowIds[startRow + r];
+          const columnId2 = columnIds[startCol + c];
+          if (rowId === void 0 || columnId2 === void 0) {
+            outside += 1;
+            continue;
+          }
+          if (!current.isColumnWritable(columnId2)) {
+            skipped.push({
+              columnId: columnId2,
+              reason: current.columnRefusal?.(columnId2) ?? `${columnId2} cannot take a pasted value.`
+            });
+            continue;
+          }
+          patches.push({ rowId, columnId: columnId2, value: line[c] ?? null });
+        }
+      }
+      const screened = screenPatches(patches);
+      void applyPatches(screened.accepted, "paste", "Pasted");
+      const tail = outside > 0 ? ` ${outside} landed past the edge of the table and were ignored.` : "";
+      announceSkips([...skipped, ...screened.refusals], `Pasted ${screened.accepted.length} cells.${tail}`);
+    },
+    [range, rowIds, columnIds, applyPatches, announceSkips, screenPatches]
+  );
+  const cellProps = useCallback7(
+    (rowId, columnId2) => {
+      const address = { rowId, fieldName: columnId2 };
+      const rowIndex = rowIndexById.get(rowId) ?? -1;
+      const colIndex = columnIndexById.get(columnId2) ?? -1;
+      const selected = bounds !== null && rowIndex >= bounds.r0 && rowIndex <= bounds.r1 && colIndex >= bounds.c0 && colIndex <= bounds.c1;
+      const active = range !== null && sameCell(range.focus, address);
+      const inFillPreview = fillTarget !== null && rowIndex >= fillTarget.top && rowIndex <= fillTarget.bottom && colIndex >= fillTarget.left && colIndex <= fillTarget.right;
+      return {
+        "data-matrx-cell-row": rowId,
+        "data-matrx-cell-col": columnId2,
+        ...selected ? { "data-matrx-cell-selected": "true" } : {},
+        ...active ? { "data-matrx-cell-active": "true" } : {},
+        ...inFillPreview ? { "data-matrx-cell-fill-preview": "true" } : {},
+        onMouseDown: (event) => {
+          if (event.button !== 0) return;
+          event.preventDefault();
+          const origin = event.currentTarget;
+          if (typeof HTMLElement !== "undefined" && origin instanceof HTMLElement) {
+            origin.closest('[data-matrx-table-spreadsheet="true"]')?.focus({ preventScroll: true });
+          }
+          setRange(
+            (previous) => event.shiftKey && previous ? { anchor: previous.anchor, focus: address } : { anchor: address, focus: address }
+          );
+          draggingRef.current = "select";
+        },
+        onMouseEnter: () => {
+          if (draggingRef.current === "select") {
+            setRange((previous) => previous ? { anchor: previous.anchor, focus: address } : previous);
+            return;
+          }
+          if (draggingRef.current === "fill" && bounds) {
+            setFillTarget(
+              fillTargetFor(
+                { top: bounds.r0, left: bounds.c0, bottom: bounds.r1, right: bounds.c1 },
+                rowIndex,
+                colIndex
+              )
+            );
+          }
+        }
+      };
+    },
+    [rowIndexById, columnIndexById, bounds, range, fillTarget]
+  );
+  const isFillHandleCell = useCallback7(
+    (rowId, columnId2) => {
+      const current = optionsRef.current;
+      if (!current || current.fillHandle === false || !bounds) return false;
+      return rowIds[bounds.r1] === rowId && columnIds[bounds.c1] === columnId2;
+    },
+    [bounds, rowIds, columnIds]
+  );
+  const startFillDrag = useCallback7(
+    (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      draggingRef.current = "fill";
+    },
+    []
+  );
+  const fillTargetRef = useRef12(null);
+  fillTargetRef.current = fillTarget;
+  const boundsRef = useRef12(null);
+  boundsRef.current = bounds;
+  useEffect11(() => {
+    if (!options) return;
+    const commit = () => {
+      const wasDragging = draggingRef.current;
+      draggingRef.current = null;
+      if (wasDragging !== "fill") return;
+      const target = fillTargetRef.current;
+      const source = boundsRef.current;
+      setFillTarget(null);
+      if (!target || !source) return;
+      const base = fillRequestBase();
+      if (!base) return;
+      const result = fillRange({
+        ...base,
+        source: { top: source.r0, left: source.c0, bottom: source.r1, right: source.c1 },
+        target
+      });
+      const screened = screenPatches(result.patches);
+      void applyPatches(screened.accepted, "fill", "Filled");
+      announceSkips([...result.skipped, ...screened.refusals], result.summary);
+    };
+    window.addEventListener("mouseup", commit);
+    return () => window.removeEventListener("mouseup", commit);
+  }, [options, fillRequestBase, applyPatches, announceSkips, screenPatches]);
+  return {
+    range,
+    bounds,
+    enabled: options !== null,
+    containerProps: {
+      tabIndex: options ? 0 : -1,
+      onKeyDown,
+      onCopy,
+      onCut,
+      onPaste
+    },
+    cellProps,
+    isFillHandleCell,
+    startFillDrag,
+    canUndo: stack.past.length > 0,
+    canRedo: stack.future.length > 0,
+    selectionTsv: selectionAsTsv,
+    selectionAddresses
+  };
+}
+
+// src/data-table/coverage.ts
+var PARTIAL_BADGE = "Partial";
+var UNKNOWN_TOTAL_BADGE = "Unknown total";
+var NUMBERS2 = new Intl.NumberFormat("en-US");
+function formatNumber(value) {
+  try {
+    return NUMBERS2.format(value);
+  } catch {
+    return String(value);
+  }
+}
+function pluralize(noun) {
+  const word = noun.trim();
+  if (!word) return "rows";
+  const lower = word.toLowerCase();
+  if (/[^aeiou]y$/.test(lower)) return `${word.slice(0, -1)}ies`;
+  if (/(s|x|z|ch|sh)$/.test(lower)) return `${word}es`;
+  return `${word}s`;
+}
+function quantity(value, noun) {
+  return `${formatNumber(value)} ${value === 1 ? noun.trim() || "row" : pluralize(noun)}`;
+}
+function toWhole(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function toOptionalWhole(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return void 0;
+  return Math.floor(value);
+}
+function describeCoverage(input) {
+  const safe = input && typeof input === "object" ? input : { loaded: 0, answeredBy: "client" };
+  const loaded = toWhole(safe.loaded);
+  const matched = toOptionalWhole(safe.matched);
+  const total = toOptionalWhole(safe.total);
+  const cap = toOptionalWhole(safe.cap);
+  const answeredBy = safe.answeredBy === "source" ? "source" : "client";
+  const noun = typeof safe.noun === "string" && safe.noun.trim() ? safe.noun.trim() : "row";
+  const reference = matched ?? total;
+  const capReached = cap !== void 0 && cap > 0 && loaded >= cap;
+  if (reference !== void 0 && loaded >= reference) {
+    return {
+      scope: "all",
+      complete: true,
+      count: { value: matched ?? reference, exact: true },
+      notice: "",
+      badge: ""
+    };
+  }
+  if (answeredBy === "source" && matched !== void 0 && !capReached) {
+    return { scope: "all", complete: true, count: { value: matched, exact: true }, notice: "", badge: "" };
+  }
+  if (capReached && cap !== void 0) {
+    const rest = reference !== void 0 ? `${quantity(reference, noun)} in this table; the rest were not looked at.` : "Anything past that was not looked at.";
+    return {
+      scope: "capped",
+      complete: false,
+      count: { value: loaded, exact: false },
+      notice: `This filter searched the first ${quantity(cap, noun)} only. ${rest}`,
+      badge: PARTIAL_BADGE
+    };
+  }
+  if (answeredBy === "client" && reference !== void 0) {
+    return {
+      scope: "loaded",
+      complete: false,
+      count: { value: loaded, exact: false },
+      notice: `Filtering the ${quantity(loaded, noun)} loaded so far, not all ${quantity(reference, noun)} in this table.`,
+      badge: PARTIAL_BADGE
+    };
+  }
+  if (answeredBy === "source" && total !== void 0) {
+    return {
+      scope: "all",
+      complete: false,
+      count: { value: loaded, exact: false },
+      notice: `Showing the ${quantity(loaded, noun)} loaded so far out of ${quantity(total, noun)} in this table.`,
+      badge: PARTIAL_BADGE
+    };
+  }
+  return {
+    scope: answeredBy === "source" ? "all" : "loaded",
+    complete: false,
+    count: { value: loaded, exact: false },
+    notice: `Showing the ${quantity(loaded, noun)} loaded so far. The total number of ${pluralize(noun)} in this table is not known.`,
+    badge: UNKNOWN_TOTAL_BADGE
+  };
+}
+
+// src/data-table/ranked-search.ts
+function inferTableSearchRole(field) {
+  const key = field.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase().replace(/[\s-]+/g, "_");
+  if (key === "id" || key === "uuid" || key.endsWith("_id")) return "id";
+  if (/^(name|alias|label|title|key|slug|display_name|common_name|model_name)$/.test(key) || /_(name|label|title)$/.test(key)) return "name";
+  if (/^(description|summary|details|notes|blurb)$/.test(key) || key.endsWith("_description")) return "description";
+  return "other";
+}
+function searchableFields(row, columns) {
+  const values = /* @__PURE__ */ new Map();
+  if (row !== null && typeof row === "object") {
+    for (const [key, value] of Object.entries(row)) values.set(key, stringifyCellValue(value));
+  }
+  for (const column of columns) {
+    if (column.accessorKey || column.accessorFn || column.filterValue) {
+      values.set(columnId(column), stringifyCellValue(getFilterValue(row, column)));
+    }
+  }
+  return values;
+}
+function resolveTableSearchScopes(rows, columns, options = {}) {
+  const fields = new Set(columns.filter((c) => c.accessorKey || c.accessorFn || c.filterValue).map(columnId));
+  for (const row of rows) if (row !== null && typeof row === "object") Object.keys(row).forEach((key) => fields.add(key));
+  const roles = new Set([...fields].map((key) => options.roles?.[key] ?? inferTableSearchRole(key)));
+  const scopes = [{ id: "all", label: "All" }];
+  for (const [id, label] of [["id", "ID"], ["name", "Name"], ["description", "Description"]]) {
+    if (roles.has(id)) scopes.push({ id, label });
+  }
+  for (const scope of options.scopes ?? []) if (!scopes.some((s) => s.id === scope.id) && scope.fields?.length) scopes.push(scope);
+  return scopes;
+}
+function rankTableSearchRows(rows, columns, query, options = {}, extraText) {
+  const q = query.trim().toLocaleLowerCase();
+  if (!q) return [...rows];
+  const scope = options.scope ?? "all";
+  const customScope = options.scopes?.find((s) => s.id === scope);
+  const mode = options.matchMode ?? "contains";
+  return rows.flatMap((row, index) => {
+    const fields = [...searchableFields(row, columns)].filter(([key]) => {
+      if (scope === "all") return true;
+      if (customScope) return customScope.fields?.includes(key) ?? false;
+      return (options.roles?.[key] ?? inferTableSearchRole(key)) === scope;
+    });
+    const extra = scope === "all" ? extraText?.(row) : void 0;
+    const texts = fields.map(([, value]) => value);
+    if (extra) texts.push(extra);
+    const matched = mode === "whole_words" ? matchesTableSearch(texts.join(" "), q, mode) : texts.some((value) => matchesTableSearch(value, q, mode));
+    if (!matched) return [];
+    let rank = 3;
+    for (const [key, value] of fields) {
+      if (!matchesTableSearch(value, q, mode)) continue;
+      const role = options.roles?.[key] ?? inferTableSearchRole(key);
+      if (role === "id" || role === "name") rank = Math.min(rank, value.trim().toLocaleLowerCase() === q ? 0 : 1);
+      else if (role === "description") rank = Math.min(rank, 2);
+    }
+    return [{ row, rank, index }];
+  }).sort((a, b) => a.rank - b.rank || a.index - b.index).map((item) => item.row);
+}
+
+// src/data-table/ColumnManager.tsx
+import { useEffect as useEffect12, useMemo as useMemo7, useState as useState17 } from "react";
+import { useDndMonitor, useDraggable as useDraggable2, useDroppable } from "@dnd-kit/core";
+import { jsx as jsx33, jsxs as jsxs23 } from "react/jsx-runtime";
+function ColumnManager({
+  open,
+  onOpenChange,
+  columns,
+  order,
+  hidden,
+  onApply
+}) {
+  const byId = useMemo7(
+    () => new Map(columns.map((column) => [columnId(column), column])),
+    [columns]
+  );
+  const [draftOrder, setDraftOrder] = useState17(order);
+  const [draftHidden, setDraftHidden] = useState17(() => new Set(hidden));
+  const [draggedColumnId, setDraggedColumnId] = useState17(null);
+  const [dropTarget, setDropTarget] = useState17(null);
+  useEffect12(() => {
+    if (!open) return;
+    setDraftOrder(order);
+    setDraftHidden(new Set(hidden));
+  }, [open, order, hidden]);
+  const move = (id, direction) => {
+    setDraftOrder((current) => {
+      const index = current.indexOf(id);
+      const target = index + direction;
+      if (index < 0 || target < 0 || target >= current.length) return current;
+      const next = [...current];
+      const displaced = next[target];
+      if (displaced === void 0) return current;
+      next[target] = id;
+      next[index] = displaced;
+      return next;
+    });
+  };
+  const moveTo = (id, targetId) => {
+    if (id === targetId) return;
+    setDraftOrder((current) => {
+      const from = current.indexOf(id);
+      const target = current.indexOf(targetId);
+      if (from < 0 || target < 0) return current;
+      const next = [...current];
+      next.splice(from, 1);
+      const targetAfterRemoval = next.indexOf(targetId);
+      next.splice(targetAfterRemoval, 0, id);
+      return next;
+    });
   };
   useDndMonitor({
     onDragStart(event) {
@@ -7381,9 +9277,9 @@ function parseTableViewSnapshot(raw) {
 
 // src/data-table/MatrxUuidCell.tsx
 import {
-  useEffect as useEffect12,
-  useRef as useRef11,
-  useState as useState17
+  useEffect as useEffect13,
+  useRef as useRef13,
+  useState as useState18
 } from "react";
 import { jsx as jsx34, jsxs as jsxs24 } from "react/jsx-runtime";
 var SHORT_LEN = 8;
@@ -7424,11 +9320,11 @@ function MatrxUuidCell({
 }) {
   const { resolveEntityDoors, ResourcePeek } = useMatrxDataTableHost();
   const { notify, notice } = useTableNotice();
-  const [copied, setCopied] = useState17(false);
-  const [opening, setOpening] = useState17(false);
-  const [peekOpen, setPeekOpen] = useState17(false);
-  const timer = useRef11(null);
-  useEffect12(
+  const [copied, setCopied] = useState18(false);
+  const [opening, setOpening] = useState18(false);
+  const [peekOpen, setPeekOpen] = useState18(false);
+  const timer = useRef13(null);
+  useEffect13(
     () => () => {
       if (timer.current) clearTimeout(timer.current);
     },
@@ -7723,7 +9619,7 @@ function DataRowInspector({
 }
 
 // src/data-table/DataRowWindow.tsx
-import { useEffect as useEffect13, useState as useState18 } from "react";
+import { useEffect as useEffect14, useState as useState19 } from "react";
 import { jsx as jsx36, jsxs as jsxs26 } from "react/jsx-runtime";
 function DataRowWindow({
   isOpen,
@@ -7744,8 +9640,8 @@ function DataRowWindow({
   const hasEdit = editContent != null;
   const hasTabs = hasEdit && children == null;
   const initialTab = defaultTab ?? (hasEdit ? "edit" : "view");
-  const [tab, setTab] = useState18(initialTab);
-  useEffect13(() => {
+  const [tab, setTab] = useState19(initialTab);
+  useEffect14(() => {
     if (!isOpen) return;
     setTab(defaultTab ?? (hasEdit ? "edit" : "view"));
   }, [isOpen, windowId, hasEdit, defaultTab]);
@@ -7895,8 +9791,8 @@ function toNumber(value) {
   if (typeof value === "string") {
     const cleaned = value.replace(/[,\s$€£¥%]/g, "");
     if (cleaned === "") return null;
-    const n = Number(cleaned);
-    return Number.isFinite(n) ? n : null;
+    const n2 = Number(cleaned);
+    return Number.isFinite(n2) ? n2 : null;
   }
   return null;
 }
@@ -7934,14 +9830,14 @@ function toList(value) {
   }
   return null;
 }
-function groupedNumber(n, options) {
+function groupedNumber(n2, options) {
   return new Intl.NumberFormat(void 0, {
     useGrouping: options.useGrouping !== false,
     ...options.precision != null ? {
       minimumFractionDigits: options.precision,
       maximumFractionDigits: options.precision
     } : { maximumFractionDigits: 10 }
-  }).format(n);
+  }).format(n2);
 }
 function affix(text, options) {
   return `${options.prefix ?? ""}${text}${options.suffix ?? ""}`;
@@ -8075,8 +9971,8 @@ var DEFS = [
     numericAlign: true,
     optionKeys: ["useGrouping", "precision", "prefix", "suffix"],
     format: (v, o) => {
-      const n = toNumber(v);
-      return n === null ? null : affix(groupedNumber(n, o), o);
+      const n2 = toNumber(v);
+      return n2 === null ? null : affix(groupedNumber(n2, o), o);
     },
     parse: (raw) => toNumber(raw)
   },
@@ -8091,9 +9987,9 @@ var DEFS = [
     numericAlign: true,
     optionKeys: ["precision", "useGrouping", "prefix", "suffix"],
     format: (v, o) => {
-      const n = toNumber(v);
-      if (n === null) return null;
-      return affix(groupedNumber(n, { ...o, precision: o.precision ?? 2 }), o);
+      const n2 = toNumber(v);
+      if (n2 === null) return null;
+      return affix(groupedNumber(n2, { ...o, precision: o.precision ?? 2 }), o);
     },
     parse: (raw) => toNumber(raw)
   },
@@ -8108,8 +10004,8 @@ var DEFS = [
     numericAlign: true,
     optionKeys: ["currency", "precision"],
     format: (v, o) => {
-      const n = toNumber(v);
-      if (n === null) return null;
+      const n2 = toNumber(v);
+      if (n2 === null) return null;
       const currency = (o.currency || "USD").toUpperCase();
       try {
         return new Intl.NumberFormat(void 0, {
@@ -8119,9 +10015,9 @@ var DEFS = [
             minimumFractionDigits: o.precision,
             maximumFractionDigits: o.precision
           } : {}
-        }).format(n);
+        }).format(n2);
       } catch {
-        return `${groupedNumber(n, { precision: o.precision ?? 2 })} ${currency}`;
+        return `${groupedNumber(n2, { precision: o.precision ?? 2 })} ${currency}`;
       }
     },
     parse: (raw) => toNumber(raw)
@@ -8137,9 +10033,9 @@ var DEFS = [
     numericAlign: true,
     optionKeys: ["percentScale", "precision"],
     format: (v, o) => {
-      const n = toNumber(v);
-      if (n === null) return null;
-      const shown = o.percentScale === "fraction" ? n * 100 : n;
+      const n2 = toNumber(v);
+      if (n2 === null) return null;
+      const shown = o.percentScale === "fraction" ? n2 * 100 : n2;
       return `${groupedNumber(shown, o.precision === void 0 ? {} : { precision: o.precision })}%`;
     },
     parse: (raw) => toNumber(raw)
@@ -8155,9 +10051,9 @@ var DEFS = [
     numericAlign: true,
     optionKeys: ["durationUnit"],
     format: (v, o) => {
-      const n = toNumber(v);
-      if (n === null) return null;
-      return formatSignedDuration(n * DURATION_TO_SECONDS[o.durationUnit ?? "seconds"]);
+      const n2 = toNumber(v);
+      if (n2 === null) return null;
+      return formatSignedDuration(n2 * DURATION_TO_SECONDS[o.durationUnit ?? "seconds"]);
     },
     parse: (raw) => toNumber(raw)
   },
@@ -8172,13 +10068,13 @@ var DEFS = [
     numericAlign: true,
     optionKeys: ["useGrouping", "prefix", "suffix"],
     format: (v, o) => {
-      const n = toNumber(v);
-      if (n === null) return null;
-      return affix(groupedNumber(Math.trunc(n), { ...o, precision: 0 }), o);
+      const n2 = toNumber(v);
+      if (n2 === null) return null;
+      return affix(groupedNumber(Math.trunc(n2), { ...o, precision: 0 }), o);
     },
     parse: (raw) => {
-      const n = toNumber(raw);
-      return n === null ? null : Math.trunc(n);
+      const n2 = toNumber(raw);
+      return n2 === null ? null : Math.trunc(n2);
     }
   },
   {
@@ -8192,15 +10088,15 @@ var DEFS = [
     rich: true,
     optionKeys: ["ratingMax"],
     format: (v, o) => {
-      const n = toNumber(v);
-      if (n === null) return null;
+      const n2 = toNumber(v);
+      if (n2 === null) return null;
       const max = o.ratingMax ?? 5;
-      if (n < 0 || n > max) return null;
-      return `${n} / ${max}`;
+      if (n2 < 0 || n2 > max) return null;
+      return `${n2} / ${max}`;
     },
     parse: (raw) => {
-      const n = toNumber(raw);
-      return n === null ? null : Math.round(n);
+      const n2 = toNumber(raw);
+      return n2 === null ? null : Math.round(n2);
     }
   },
   {
@@ -8213,12 +10109,12 @@ var DEFS = [
     editor: "number",
     numericAlign: true,
     format: (v) => {
-      const n = toNumber(v);
-      return n === null ? null : formatFileSize(n);
+      const n2 = toNumber(v);
+      return n2 === null ? null : formatFileSize(n2);
     },
     parse: (raw) => {
-      const n = toNumber(raw);
-      return n === null ? null : Math.trunc(n);
+      const n2 = toNumber(raw);
+      return n2 === null ? null : Math.trunc(n2);
     }
   },
   // ── Choice ────────────────────────────────────────────────────────────────
@@ -8628,8 +10524,19 @@ function DirtySavePill({
 }
 
 // src/data-table/EditableTableCell.tsx
-import { useEffect as useEffect14, useRef as useRef12, useState as useState19 } from "react";
+import { useEffect as useEffect15, useRef as useRef14, useState as useState20 } from "react";
 import { jsx as jsx39, jsxs as jsxs29 } from "react/jsx-runtime";
+function CellRefusal({ reason }) {
+  return /* @__PURE__ */ jsx39(
+    "p",
+    {
+      role: "alert",
+      "data-matrx-cell-refusal": "true",
+      className: "mt-1 text-[11px] leading-snug text-amber-700 dark:text-amber-400",
+      children: reason
+    }
+  );
+}
 function CellEditShell({
   href,
   display,
@@ -8676,12 +10583,17 @@ function EditableTableCell({
   className,
   href,
   editTrigger = "click",
-  editRequest
+  editRequest,
+  editSeed
 }) {
-  const [open, setOpen] = useState19(false);
-  useEffect14(() => {
+  const [open, setOpen] = useState20(false);
+  const [refusal, setRefusal] = useState20(null);
+  useEffect15(() => {
     if (editRequest !== void 0) setOpen(true);
   }, [editRequest]);
+  useEffect15(() => {
+    if (!open) setRefusal(null);
+  }, [open]);
   const usePencil = Boolean(href) || editTrigger === "pencil";
   if (editType === "string") {
     return /* @__PURE__ */ jsx39(
@@ -8694,7 +10606,8 @@ function EditableTableCell({
         ...className === void 0 ? {} : { className },
         ...href === void 0 ? {} : { href },
         usePencil,
-        ...editRequest === void 0 ? {} : { editRequest }
+        ...editRequest === void 0 ? {} : { editRequest },
+        ...editSeed === void 0 || editSeed === null ? {} : { editSeed }
       }
     );
   }
@@ -8739,25 +10652,33 @@ function EditableTableCell({
       ) }) }),
       /* @__PURE__ */ jsx39(TooltipContent, { children: "Edit value" })
     ] }),
-    /* @__PURE__ */ jsx39(
+    /* @__PURE__ */ jsxs29(
       PopoverContent,
       {
         align: "start",
-        className: "w-56 p-2",
-        onClick: (e) => e.stopPropagation(),
-        children: /* @__PURE__ */ jsx39(
-          TypedEditor,
-          {
-            editType,
-            value,
-            editOptions,
-            onCommit: (next) => {
-              onCommit(next);
-              setOpen(false);
-            },
-            onCancel: () => setOpen(false)
-          }
-        )
+        className: "w-56 p-2",
+        onClick: (e) => e.stopPropagation(),
+        children: [
+          /* @__PURE__ */ jsx39(
+            TypedEditor,
+            {
+              editType,
+              value,
+              editOptions,
+              onCommit: (next) => {
+                const refused = onCommit(next);
+                if (typeof refused === "string" && refused) {
+                  setRefusal(refused);
+                  return;
+                }
+                setRefusal(null);
+                setOpen(false);
+              },
+              onCancel: () => setOpen(false)
+            }
+          ),
+          refusal ? /* @__PURE__ */ jsx39(CellRefusal, { reason: refusal }) : null
+        ]
       }
     )
   ] });
@@ -8770,17 +10691,31 @@ function InlineStringEditor({
   className,
   href,
   usePencil,
-  editRequest
+  editRequest,
+  editSeed
 }) {
-  const [editing, setEditing] = useState19(false);
-  const [draft, setDraft] = useState19(value);
-  const handledEditRequest = useRef12(void 0);
-  useEffect14(() => {
+  const [editing, setEditing] = useState20(false);
+  const [draft, setDraft] = useState20(value);
+  const [refusal, setRefusal] = useState20(null);
+  const handledEditRequest = useRef14(void 0);
+  const seedRef = useRef14(editSeed);
+  seedRef.current = editSeed;
+  useEffect15(() => {
     if (editRequest === void 0 || handledEditRequest.current === editRequest) return;
     handledEditRequest.current = editRequest;
-    setDraft(value);
+    setDraft(seedRef.current ?? value);
+    setRefusal(null);
     setEditing(true);
   }, [editRequest, value]);
+  const commit = (next) => {
+    const refused = onCommit(next);
+    if (typeof refused === "string" && refused) {
+      setRefusal(refused);
+      return false;
+    }
+    setRefusal(null);
+    return true;
+  };
   if (!editing) {
     if (usePencil) {
       return /* @__PURE__ */ jsx39(
@@ -8831,32 +10766,38 @@ function InlineStringEditor({
       /* @__PURE__ */ jsx39(TooltipContent, { children: "Click to edit" })
     ] });
   }
-  return /* @__PURE__ */ jsx39(
-    Input,
-    {
-      autoFocus: true,
-      value: draft,
-      onClick: (e) => e.stopPropagation(),
-      onChange: (e) => setDraft(e.target.value),
-      onBlur: () => {
-        onCommit(draft);
-        setEditing(false);
-      },
-      onKeyDown: (e) => {
-        if (e.key === "Enter") {
-          e.preventDefault();
-          onCommit(draft);
-          setEditing(false);
-        }
-        if (e.key === "Escape") {
-          e.preventDefault();
-          setEditing(false);
-        }
-      },
-      className: "h-7 text-sm",
-      style: { fontSize: "16px" }
-    }
-  );
+  return /* @__PURE__ */ jsxs29("span", { className: "block w-full", children: [
+    /* @__PURE__ */ jsx39(
+      Input,
+      {
+        autoFocus: true,
+        value: draft,
+        onClick: (e) => e.stopPropagation(),
+        onChange: (e) => {
+          setDraft(e.target.value);
+          if (refusal) setRefusal(null);
+        },
+        onBlur: () => {
+          if (commit(draft)) setEditing(false);
+        },
+        onKeyDown: (e) => {
+          if (e.key === "Enter") {
+            e.preventDefault();
+            if (commit(draft)) setEditing(false);
+          }
+          if (e.key === "Escape") {
+            e.preventDefault();
+            setRefusal(null);
+            setEditing(false);
+          }
+        },
+        "aria-invalid": refusal ? true : void 0,
+        className: cn("h-7 text-sm", refusal && "border-amber-500 focus-visible:ring-amber-500"),
+        style: { fontSize: "16px" }
+      }
+    ),
+    refusal ? /* @__PURE__ */ jsx39(CellRefusal, { reason: refusal }) : null
+  ] });
 }
 function TypedEditor({
   editType,
@@ -8931,8 +10872,8 @@ function TagsEditor({
   onCommit,
   onCancel
 }) {
-  const [tags, setTags] = useState19(value);
-  const [draft, setDraft] = useState19("");
+  const [tags, setTags] = useState20(value);
+  const [draft, setDraft] = useState20("");
   const add = (raw) => {
     const next = raw.trim();
     if (!next || tags.includes(next)) return;
@@ -9029,7 +10970,7 @@ function NumberEditor({
   onCommit,
   onCancel
 }) {
-  const [draft, setDraft] = useState19(String(value));
+  const [draft, setDraft] = useState20(String(value));
   return /* @__PURE__ */ jsxs29("div", { className: "flex flex-col gap-2", children: [
     /* @__PURE__ */ jsx39(
       Input,
@@ -9041,8 +10982,8 @@ function NumberEditor({
         style: { fontSize: "16px" },
         onKeyDown: (e) => {
           if (e.key === "Enter") {
-            const n = Number(draft);
-            if (Number.isFinite(n)) onCommit(n);
+            const n2 = Number(draft);
+            if (Number.isFinite(n2)) onCommit(n2);
           }
           if (e.key === "Escape") onCancel();
         }
@@ -9069,8 +11010,8 @@ function NumberEditor({
           className: "h-7",
           "aria-label": "Apply value",
           onClick: () => {
-            const n = Number(draft);
-            if (Number.isFinite(n)) onCommit(n);
+            const n2 = Number(draft);
+            if (Number.isFinite(n2)) onCommit(n2);
           },
           children: /* @__PURE__ */ jsx39(Check, { className: "h-3.5 w-3.5" })
         }
@@ -9159,7 +11100,7 @@ function resetToolbarFacets(facets) {
 }
 
 // src/data-table/LayeredFilterBuilder.tsx
-import { useState as useState20 } from "react";
+import { useState as useState21 } from "react";
 import { Fragment as Fragment5, jsx as jsx41, jsxs as jsxs31 } from "react/jsx-runtime";
 function moveRule(rules, from, to) {
   if (from === to || to < 0 || to >= rules.length) return [...rules];
@@ -9176,8 +11117,8 @@ function LayeredFilterBuilder({
   maxRules = 20,
   label = "Advanced filters"
 }) {
-  const [open, setOpen] = useState20(false);
-  const [draggedIndex, setDraggedIndex] = useState20(null);
+  const [open, setOpen] = useState21(false);
+  const [draggedIndex, setDraggedIndex] = useState21(null);
   if (fields.length === 0) return null;
   const updateRule = (index, patch) => {
     onChange(
@@ -9721,7 +11662,7 @@ function MatrxDataTableWithUrlState({
     ...urlState.history === void 0 ? {} : { history: urlState.history },
     ...urlState.textHistory === void 0 ? {} : { textHistory: urlState.textHistory }
   });
-  useEffect15(() => {
+  useEffect16(() => {
     if (activeUrlTableIds.has(urlState.id)) {
       throw new Error(
         `Duplicate MatrxDataTable urlState.id "${urlState.id}" on one page. Give every table a unique stable id.`
@@ -9812,6 +11753,11 @@ function opensRowHref(event) {
 function TableContextPassthrough({ children }) {
   return /* @__PURE__ */ jsx42(Fragment7, { children });
 }
+function sameWindow(a, b) {
+  if (a === null || b === null) return a === b;
+  return a.start === b.start && a.end === b.end && a.padStart === b.padStart && a.padEnd === b.padEnd && a.total === b.total && a.pinned.length === b.pinned.length;
+}
+var NO_GROUPING_VALUE = "__matrx_no_grouping__";
 function MatrxDataTableCore({
   data: suppliedData,
   columns,
@@ -9868,11 +11814,17 @@ function MatrxDataTableCore({
   mobileCardsBreakpoint = "sm",
   getRowHref,
   onRowOpen,
-  density
+  density,
+  grouping,
+  virtualize,
+  coverage,
+  spreadsheet,
+  facets,
+  rowHeight: explicitRowHeight
 }) {
   const appendQuery = query?.mode === "controlled-append" ? query : null;
   const appendQueryKey = appendQuery?.pagination.queryKey ?? null;
-  const committedAppendQueryKey = useRef13(appendQueryKey);
+  const committedAppendQueryKey = useRef15(appendQueryKey);
   const appendSourceChanged = appendQuery !== null && committedAppendQueryKey.current !== appendQueryKey;
   const data = (appendQuery ? appendQuery.pagination.rows : suppliedData) ?? [];
   const isLoading = appendQuery ? appendQuery.pagination.loading : suppliedLoading;
@@ -9884,10 +11836,10 @@ function MatrxDataTableCore({
   const Link = host.Link ?? DefaultTableLink;
   const SidePanelSurface = host.SidePanelSurface ?? DefaultTableSidePanel;
   const { notify: toast, notice } = useTableNotice();
-  const [savedViewError, setSavedViewError] = useState21(null);
-  const [toolbarActionError, setToolbarActionError] = useState21(null);
-  const [toolbarActionPending, setToolbarActionPending] = useState21({ refresh: false, add: false });
-  const toolbarActionPendingRef = useRef13({ refresh: false, add: false });
+  const [savedViewError, setSavedViewError] = useState22(null);
+  const [toolbarActionError, setToolbarActionError] = useState22(null);
+  const [toolbarActionPending, setToolbarActionPending] = useState22({ refresh: false, add: false });
+  const toolbarActionPendingRef = useRef15({ refresh: false, add: false });
   const CHECKBOX_TAP_AREA = "h-4 w-4 touch-manipulation";
   const mobileCardsClass = mobileCardsBreakpoint === "lg" ? "lg:hidden" : "sm:hidden";
   const tableWithCardsClass = mobileCardsBreakpoint === "lg" ? "max-lg:hidden" : "max-sm:hidden";
@@ -9900,7 +11852,7 @@ function MatrxDataTableCore({
   const sourceOwnsIntelligentSearch = sourceProcessing?.intelligentSearch === "source";
   const sourceOwnsSearch = remoteQuery?.mode === "controlled" || appendQuery !== null && sourceProcessing === void 0 || sourceProcessing?.search === "source" || sourceOwnsIntelligentSearch;
   const intelligentSearchEnabled = toolbar?.intelligentSearch !== void 0 && (sourceOwnsIntelligentSearch || remoteQuery === null && !sourceOwnsSearch);
-  const emitControlledQueryChange = useCallback7(
+  const emitControlledQueryChange = useCallback8(
     (patch, options) => {
       if (!controlledQuery) return;
       controlledQuery.onStateChange(
@@ -9909,8 +11861,8 @@ function MatrxDataTableCore({
     },
     [controlledQuery]
   );
-  const [internalSearch, setInternalSearch] = useState21("");
-  const [draggedRowId, setDraggedRowId] = useState21(null);
+  const [internalSearch, setInternalSearch] = useState22("");
+  const [draggedRowId, setDraggedRowId] = useState22(null);
   const hierarchySensors = useSensors(
     useSensor(PointerSensor, {
       activationConstraint: { distance: COLUMN_REORDER_ACTIVATION_DISTANCE }
@@ -9926,7 +11878,7 @@ function MatrxDataTableCore({
     }
     toolbar?.onSearchChange?.(v);
   };
-  const [internalSearchMatchMode, setInternalSearchMatchMode] = useState21(
+  const [internalSearchMatchMode, setInternalSearchMatchMode] = useState22(
     toolbar?.searchMatch?.defaultMode ?? "contains"
   );
   const searchMatchMode = controlledQuery ? controlledQuery.state.searchMatchMode ?? toolbar?.searchMatch?.defaultMode ?? "contains" : internalSearchMatchMode;
@@ -9937,7 +11889,7 @@ function MatrxDataTableCore({
     }
     setInternalSearchMatchMode(mode);
   };
-  const [internalSearchScope, setInternalSearchScope] = useState21("all");
+  const [internalSearchScope, setInternalSearchScope] = useState22("all");
   const searchScope = controlledQuery ? controlledQuery.state.searchScope ?? "all" : internalSearchScope;
   const setSearchScope = (scope) => {
     if (controlledQuery) {
@@ -9946,7 +11898,7 @@ function MatrxDataTableCore({
     }
     setInternalSearchScope(scope);
   };
-  const [internalAnyOf, setInternalAnyOf] = useState21("");
+  const [internalAnyOf, setInternalAnyOf] = useState22("");
   const toolbarAnyOfControlled = toolbar?.anyOf?.value !== void 0;
   const anyOfValue = controlledQuery ? controlledQuery.state.anyOf : toolbarAnyOfControlled ? toolbar?.anyOf?.value ?? "" : internalAnyOf;
   const setAnyOfValue = (v) => {
@@ -9957,7 +11909,7 @@ function MatrxDataTableCore({
     }
     toolbar?.anyOf?.onChange?.(v);
   };
-  const [internalLayeredFilters, setInternalLayeredFilters] = useState21([]);
+  const [internalLayeredFilters, setInternalLayeredFilters] = useState22([]);
   const layeredFilters = controlledQuery ? controlledQuery.state.layeredFilters ?? [] : internalLayeredFilters;
   const setLayeredFilters = (next) => {
     if (controlledQuery) {
@@ -9966,7 +11918,7 @@ function MatrxDataTableCore({
     }
     setInternalLayeredFilters(next);
   };
-  const [internalColumnFilters, setInternalColumnFilters] = useState21({});
+  const [internalColumnFilters, setInternalColumnFilters] = useState22({});
   const columnFilters = controlledQuery ? controlledQuery.state.columnFilters : internalColumnFilters;
   const setColumnFilter = (id, next) => {
     const nextFilters = { ...columnFilters, [id]: next };
@@ -9979,7 +11931,7 @@ function MatrxDataTableCore({
     }
     setInternalColumnFilters(nextFilters);
   };
-  const [internalSort, setInternalSort] = useState21(defaultSort);
+  const [internalSort, setInternalSort] = useState22(defaultSort);
   const sort = controlledQuery ? controlledQuery.state.sort : internalSort;
   const setSort = (next) => {
     if (controlledQuery) {
@@ -9988,7 +11940,7 @@ function MatrxDataTableCore({
     }
     setInternalSort(next);
   };
-  const [internalPage, setInternalPage] = useState21(1);
+  const [internalPage, setInternalPage] = useState22(1);
   const page = controlledQuery ? controlledQuery.state.page : internalPage;
   const setPage = (next) => {
     if (controlledQuery) {
@@ -9997,7 +11949,7 @@ function MatrxDataTableCore({
     }
     setInternalPage(next);
   };
-  const [internalPageSize, setInternalPageSize] = useState21(
+  const [internalPageSize, setInternalPageSize] = useState22(
     defaultPageSize
   );
   const pageSize = controlledQuery ? controlledQuery.state.pageSize : internalPageSize;
@@ -10008,28 +11960,28 @@ function MatrxDataTableCore({
     }
     setInternalPageSize(next);
   };
-  const [uncontrolledSelectedId, setUncontrolledSelectedId] = useState21(null);
+  const [uncontrolledSelectedId, setUncontrolledSelectedId] = useState22(null);
   const rawSelectedId = controlledSelectedId !== void 0 ? controlledSelectedId : uncontrolledSelectedId;
   const selectedId = appendSourceChanged ? null : rawSelectedId;
   const setSelectedId = (id) => {
     if (controlledSelectedId === void 0) setUncontrolledSelectedId(id);
     onSelectedIdChange?.(id);
   };
-  const [uncontrolledWindowRowId, setUncontrolledWindowRowId] = useState21(null);
+  const [uncontrolledWindowRowId, setUncontrolledWindowRowId] = useState22(null);
   const rawWindowRowId = controlledWindowRowId !== void 0 ? controlledWindowRowId : uncontrolledWindowRowId;
   const windowRowId = appendSourceChanged ? null : rawWindowRowId;
   const setWindowRowId = (id) => {
     if (controlledWindowRowId === void 0) setUncontrolledWindowRowId(id);
     onWindowRowIdChange?.(id);
   };
-  const [windowRowSnapshot, setWindowRowSnapshot] = useState21(null);
+  const [windowRowSnapshot, setWindowRowSnapshot] = useState22(null);
   const editScopeKey = appendQueryKey === null ? "\0local" : `append:${appendQueryKey}`;
-  const [editsByScope, setEditsByScope] = useState21({});
-  const editRevisionRef = useRef13({});
-  const [savingByScope, setSavingByScope] = useState21({});
-  const savingScopesRef = useRef13(/* @__PURE__ */ new Set());
-  const [editRequest, setEditRequest] = useState21(null);
-  const [confirmForeignDraftDiscard, setConfirmForeignDraftDiscard] = useState21(false);
+  const [editsByScope, setEditsByScope] = useState22({});
+  const editRevisionRef = useRef15({});
+  const [savingByScope, setSavingByScope] = useState22({});
+  const savingScopesRef = useRef15(/* @__PURE__ */ new Set());
+  const [editRequest, setEditRequest] = useState22(null);
+  const [confirmForeignDraftDiscard, setConfirmForeignDraftDiscard] = useState22(false);
   const edits = editsByScope[editScopeKey]?.values ?? {};
   const saving = (savingByScope[editScopeKey] ?? 0) > 0;
   const setEdits = (next) => {
@@ -10096,7 +12048,7 @@ function MatrxDataTableCore({
     rows: Object.entries(draft.values).map(([rowId, columns2]) => ({ rowId, columns: columns2 }))
   }));
   const selection = appendSourceChanged && selectionConfig ? { ...selectionConfig, selectedIds: [] } : selectionConfig;
-  useEffect15(() => {
+  useEffect16(() => {
     const previous = committedAppendQueryKey.current;
     committedAppendQueryKey.current = appendQueryKey;
     if (previous === null || appendQueryKey === null || previous === appendQueryKey) {
@@ -10114,13 +12066,13 @@ function MatrxDataTableCore({
     onWindowRowIdChange,
     selectionConfig
   ]);
-  const scrollRef = useRef13(null);
-  const tableRef = useRef13(null);
-  const tableHeaderRef = useRef13(null);
-  const cardsScrollRef = useRef13(null);
-  const [documentStickyHeader, setDocumentStickyHeader] = useState21(false);
-  const documentStickyHeaderRef = useRef13(false);
-  const previousAppendKeyForScrollReset = useRef13(appendQueryKey);
+  const scrollRef = useRef15(null);
+  const tableRef = useRef15(null);
+  const tableHeaderRef = useRef15(null);
+  const cardsScrollRef = useRef15(null);
+  const [documentStickyHeader, setDocumentStickyHeader] = useState22(false);
+  const documentStickyHeaderRef = useRef15(false);
+  const previousAppendKeyForScrollReset = useRef15(appendQueryKey);
   useLayoutEffect2(() => {
     const previous = previousAppendKeyForScrollReset.current;
     previousAppendKeyForScrollReset.current = appendQueryKey;
@@ -10146,13 +12098,13 @@ function MatrxDataTableCore({
     ...appendScrollPolicy?.mode === "scroll" && appendScrollPolicy.thresholdPx !== void 0 ? { thresholdPx: appendScrollPolicy.thresholdPx } : {},
     ...appendScrollPolicy?.mode === "scroll" && appendScrollPolicy.intentTimeoutMs !== void 0 ? { intentTimeoutMs: appendScrollPolicy.intentTimeoutMs } : {}
   });
-  const rootRef = useRef13(null);
+  const rootRef = useRef15(null);
   useClippedContentGuard(rootRef, {
     label: typeof copy === "object" && copy.listLabel ? `Table: ${copy.listLabel}` : "MatrxDataTable"
   });
-  const [scrollHintRight, setScrollHintRight] = useState21(false);
-  const [scrollHintLeft, setScrollHintLeft] = useState21(false);
-  const updateScrollHint = useCallback7(() => {
+  const [scrollHintRight, setScrollHintRight] = useState22(false);
+  const [scrollHintLeft, setScrollHintLeft] = useState22(false);
+  const updateScrollHint = useCallback8(() => {
     const el = scrollRef.current;
     if (!el) return;
     setScrollHintRight(el.scrollLeft + el.clientWidth < el.scrollWidth - 2);
@@ -10166,7 +12118,7 @@ function MatrxDataTableCore({
       behavior: "smooth"
     });
   };
-  useEffect15(() => {
+  useEffect16(() => {
     updateScrollHint();
     window.addEventListener("resize", updateScrollHint);
     const el = scrollRef.current;
@@ -10240,30 +12192,30 @@ function MatrxDataTableCore({
       window.removeEventListener("resize", requestUpdate);
     };
   }, [stickyHeader, data, columns]);
-  const [columnOrder, setColumnOrder] = useState21(() => columnState?.order ?? columns.map(columnId));
-  const [hiddenColumnIds, setHiddenColumnIds] = useState21(
+  const [columnOrder, setColumnOrder] = useState22(() => columnState?.order ?? columns.map(columnId));
+  const [hiddenColumnIds, setHiddenColumnIds] = useState22(
     () => new Set(columnState?.hidden ?? columns.filter((column) => column.hidden).map(columnId))
   );
-  const [columnWidths, setColumnWidths] = useState21(
+  const [columnWidths, setColumnWidths] = useState22(
     () => normalizeColumnWidthsForColumns(columnState?.widths, columns)
   );
-  const [fixedTableGeometry, setFixedTableGeometry] = useState21(null);
-  const knownColumnIds = useRef13(new Set(columns.map(columnId)));
-  const draggedColumnId = useRef13(null);
-  const columnDragActive = useRef13(false);
-  const columnDragRaf = useRef13(null);
-  const columnDragScrollDirection = useRef13(0);
-  const [columnDragPreview, setColumnDragPreview] = useState21(null);
-  const stopColumnDragScroll = useCallback7(() => {
+  const [fixedTableGeometry, setFixedTableGeometry] = useState22(null);
+  const knownColumnIds = useRef15(new Set(columns.map(columnId)));
+  const draggedColumnId = useRef15(null);
+  const columnDragActive = useRef15(false);
+  const columnDragRaf = useRef15(null);
+  const columnDragScrollDirection = useRef15(0);
+  const [columnDragPreview, setColumnDragPreview] = useState22(null);
+  const stopColumnDragScroll = useCallback8(() => {
     if (columnDragRaf.current !== null) cancelAnimationFrame(columnDragRaf.current);
     columnDragRaf.current = null;
     columnDragScrollDirection.current = 0;
   }, []);
-  useEffect15(() => () => {
+  useEffect16(() => () => {
     columnDragActive.current = false;
     stopColumnDragScroll();
   }, [stopColumnDragScroll]);
-  const startColumnDragScroll = useCallback7(() => {
+  const startColumnDragScroll = useCallback8(() => {
     if (!columnDragActive.current || columnDragRaf.current !== null) return;
     const scrollStep = () => {
       const scroll = scrollRef.current;
@@ -10290,25 +12242,25 @@ function MatrxDataTableCore({
     };
     columnDragRaf.current = requestAnimationFrame(scrollStep);
   }, []);
-  const commitColumnState = useCallback7((order, hidden) => {
+  const commitColumnState = useCallback8((order, hidden) => {
     if (columnState) columnState.onChange({ order, hidden: [...hidden] });
     else {
       setColumnOrder(order);
       setHiddenColumnIds(hidden);
     }
   }, [columnState]);
-  const [internalColumnManagerOpen, setInternalColumnManagerOpen] = useState21(false);
+  const [internalColumnManagerOpen, setInternalColumnManagerOpen] = useState22(false);
   const columnManagerOpen = controlledColumnManager?.open ?? internalColumnManagerOpen;
   const setColumnManagerOpen = controlledColumnManager?.onOpenChange ?? setInternalColumnManagerOpen;
-  const columnIds = useMemo7(() => columns.map(columnId), [columns]);
-  const effectiveColumnOrder = useMemo7(() => columnState ? [...columnState.order.filter((id, index, values) => columnIds.includes(id) && values.indexOf(id) === index), ...columnIds.filter((id) => !columnState.order.includes(id))] : columnOrder, [columnIds, columnOrder, columnState]);
-  const effectiveHiddenColumnIds = useMemo7(() => columnState ? new Set(columnState.hidden.filter((id) => columnIds.includes(id))) : hiddenColumnIds, [columnIds, columnState, hiddenColumnIds]);
-  const effectiveColumnWidths = useMemo7(
+  const columnIds = useMemo8(() => columns.map(columnId), [columns]);
+  const effectiveColumnOrder = useMemo8(() => columnState ? [...columnState.order.filter((id, index, values) => columnIds.includes(id) && values.indexOf(id) === index), ...columnIds.filter((id) => !columnState.order.includes(id))] : columnOrder, [columnIds, columnOrder, columnState]);
+  const effectiveHiddenColumnIds = useMemo8(() => columnState ? new Set(columnState.hidden.filter((id) => columnIds.includes(id))) : hiddenColumnIds, [columnIds, columnState, hiddenColumnIds]);
+  const effectiveColumnWidths = useMemo8(
     () => normalizeColumnWidthsForColumns(columnState?.widths ?? columnWidths, columns),
     [columns, columnState?.widths, columnWidths]
   );
-  const resizeGestureSnapshotRef = useRef13(null);
-  const measureVisibleColumnWidths = useCallback7(() => {
+  const resizeGestureSnapshotRef = useRef15(null);
+  const measureVisibleColumnWidths = useCallback8(() => {
     const measured = {};
     const headers = tableRef.current ? Array.from(tableRef.current.querySelectorAll(
       "thead th[data-matrx-table-column-id]"
@@ -10322,7 +12274,7 @@ function MatrxDataTableCore({
     }
     return normalizeColumnWidthsForColumns(measured, columns);
   }, [columns]);
-  const measureFixedTableGeometry = useCallback7(() => {
+  const measureFixedTableGeometry = useCallback8(() => {
     const table = tableRef.current;
     const headers = table ? Array.from(table.querySelectorAll("thead th")) : [];
     const widthFor = (selector) => {
@@ -10357,16 +12309,16 @@ function MatrxDataTableCore({
       ...actionsWidth === void 0 ? {} : { actionsWidth }
     };
   }, [resolvedDensity]);
-  const captureResizeGestureSnapshot = useCallback7(() => {
+  const captureResizeGestureSnapshot = useCallback8(() => {
     resizeGestureSnapshotRef.current = {
       widths: measureVisibleColumnWidths(),
       geometry: measureFixedTableGeometry()
     };
   }, [measureFixedTableGeometry, measureVisibleColumnWidths]);
-  const clearResizeGestureSnapshot = useCallback7(() => {
+  const clearResizeGestureSnapshot = useCallback8(() => {
     resizeGestureSnapshotRef.current = null;
   }, []);
-  const commitColumnWidths = useCallback7((next, captureInitialWidths = false) => {
+  const commitColumnWidths = useCallback8((next, captureInitialWidths = false) => {
     const gestureSnapshot = captureInitialWidths ? resizeGestureSnapshotRef.current : null;
     resizeGestureSnapshotRef.current = null;
     const normalized = normalizeColumnWidthsForColumns(
@@ -10385,7 +12337,7 @@ function MatrxDataTableCore({
     }
     setColumnWidths(normalized);
   }, [columnIds, columnState, columns, measureFixedTableGeometry, measureVisibleColumnWidths]);
-  useEffect15(() => {
+  useEffect16(() => {
     const ids = columns.map(columnId);
     if (columnState) return;
     const previousIds = knownColumnIds.current;
@@ -10409,12 +12361,12 @@ function MatrxDataTableCore({
       tableRef.current?.style.removeProperty(columnResizeCssVar(id));
     }
   });
-  const previewColumnOrder = useMemo7(
+  const previewColumnOrder = useMemo8(
     () => projectColumnDragOrder(effectiveColumnOrder, columnDragPreview),
     [columnDragPreview, effectiveColumnOrder]
   );
   useColumnReorderAnimation(tableRef, previewColumnOrder.join("\0"), columnDragPreview !== null);
-  const visibleColumns = useMemo7(() => {
+  const visibleColumns = useMemo8(() => {
     const byId = new Map(columns.map((column) => [columnId(column), column]));
     return previewColumnOrder.map((id) => byId.get(id)).filter(
       (column) => column !== void 0 && !effectiveHiddenColumnIds.has(columnId(column))
@@ -10450,7 +12402,7 @@ function MatrxDataTableCore({
     setFixedTableGeometry(geometry);
   }, [resolvedDensity, measureFixedTableGeometry, usesMeasuredFixedLayout]);
   const fixedLayoutActive = usesMeasuredFixedLayout && fixedTableGeometry !== null;
-  const frozenColumns = useMemo7(() => {
+  const frozenColumns = useMemo8(() => {
     if (!visibleColumns.some((column) => column.frozen)) return NO_FROZEN_COLUMNS;
     const ids = visibleColumns.map(columnId);
     const byId = new Map(visibleColumns.map((column) => [columnId(column), column]));
@@ -10492,7 +12444,7 @@ function MatrxDataTableCore({
     );
     return color ? CELL_TINT_CLASS[color] : void 0;
   };
-  const declaredVisibleCopyColumns = useMemo7(
+  const declaredVisibleCopyColumns = useMemo8(
     () => visibleColumns.filter((column) => column.accessorFn !== void 0 || column.accessorKey !== void 0),
     [visibleColumns]
   );
@@ -10500,7 +12452,7 @@ function MatrxDataTableCore({
   const tableContextMenuInstanceId = useId2();
   const tableDndContextId = useId2();
   const defaultCopyTitle = toolbar?.title || "Table";
-  const defaultCopy = useMemo7(() => ({
+  const defaultCopy = useMemo8(() => ({
     label: defaultCopyTitle,
     listLabel: defaultCopyTitle,
     location: defaultCopyTitle,
@@ -10535,7 +12487,7 @@ function MatrxDataTableCore({
       serializer: (shaped) => buildViewAgentInput(effectiveCopy, shaped, data, { scope: "custom" })
     }))
   ] : [];
-  const filterMeta = useMemo7(() => {
+  const filterMeta = useMemo8(() => {
     const meta = /* @__PURE__ */ new Map();
     for (const col of visibleColumns) {
       const id = columnId(col);
@@ -10543,14 +12495,14 @@ function MatrxDataTableCore({
     }
     return meta;
   }, [visibleColumns, data, remoteQuery]);
-  const intelligentSearchScopes = useMemo7(
+  const intelligentSearchScopes = useMemo8(
     () => resolveTableSearchScopes(data, columns, {
       ...toolbar?.intelligentSearch?.roles === void 0 ? {} : { roles: toolbar.intelligentSearch.roles },
       ...toolbar?.intelligentSearch?.scopes === void 0 ? {} : { scopes: toolbar.intelligentSearch.scopes }
     }),
     [columns, data, toolbar?.intelligentSearch?.roles, toolbar?.intelligentSearch?.scopes]
   );
-  const processed = useMemo7(() => {
+  const processed = useMemo8(() => {
     if (remoteQuery && !appendUsesLocalProcessing) return data;
     if (processLocalRows) {
       return processLocalRows(data, {
@@ -10613,8 +12565,8 @@ function MatrxDataTableCore({
     intelligentSearchEnabled,
     searchScope
   ]);
-  const lastNotifiedViewRows = useRef13(null);
-  useEffect15(() => {
+  const lastNotifiedViewRows = useRef15(null);
+  useEffect16(() => {
     if (!onViewChange) {
       lastNotifiedViewRows.current = null;
       return;
@@ -10623,7 +12575,7 @@ function MatrxDataTableCore({
     lastNotifiedViewRows.current = processed;
     if (changed) onViewChange(processed);
   }, [processed, onViewChange]);
-  useEffect15(() => {
+  useEffect16(() => {
     if (controlledQuery) return;
     setInternalPage(1);
   }, [
@@ -10667,7 +12619,7 @@ function MatrxDataTableCore({
     numberedPageHasMore: !hidePagination && !isLoading && !isFetching && processed.length > 0 && safePage < pageCount && (remoteQuery?.mode === "controlled" || !remoteQuery && localPagination?.mode === "numbered"),
     onPageAdvance: setPage
   });
-  const paginated = useMemo7(() => {
+  const paginated = useMemo8(() => {
     if (remoteQuery) return processed;
     if (hidePagination) return processed;
     if (localProgressiveEnabled) return [...progressiveRows.rows];
@@ -10675,15 +12627,351 @@ function MatrxDataTableCore({
     const start = (safePage - 1) * effectivePageSize;
     return processed.slice(start, start + effectivePageSize);
   }, [processed, safePage, effectivePageSize, pageSize, remoteQuery, hidePagination, localProgressiveEnabled, progressiveRows.rows]);
-  useEffect15(() => {
+  const groupingColumnId = grouping?.columnId ?? null;
+  const [uncontrolledCollapsed, setUncontrolledCollapsed] = useState22([]);
+  const collapsedGroups = grouping?.collapsed ?? uncontrolledCollapsed;
+  const setCollapsedGroups = useCallback8(
+    (next) => {
+      if (grouping?.onCollapsedChange) grouping.onCollapsedChange(next);
+      else setUncontrolledCollapsed(next);
+    },
+    [grouping]
+  );
+  const groups = useMemo8(() => {
+    if (!grouping || !groupingColumnId) return null;
+    const groupColumn = columns.find((col) => columnId(col) === groupingColumnId);
+    if (!groupColumn) return null;
+    const aggregateColumns = {};
+    for (const [aggColumnId, spec] of Object.entries(grouping.aggregates ?? {})) {
+      const col = columns.find((c) => columnId(c) === aggColumnId);
+      if (!col) continue;
+      aggregateColumns[aggColumnId] = { spec, readCell: (row) => getCellValue(row, col) };
+    }
+    return groupRows({
+      rows: paginated,
+      columnId: groupingColumnId,
+      readCell: (row) => grouping.readCell ? grouping.readCell(row, groupingColumnId) : getCellValue(row, groupColumn),
+      aggregates: aggregateColumns,
+      ...grouping.order ? { order: grouping.order } : {},
+      ...grouping.emptyLabel ? { emptyLabel: grouping.emptyLabel } : {}
+    });
+  }, [grouping, groupingColumnId, columns, paginated]);
+  const groupableColumns = useMemo8(() => {
+    const allowed = grouping?.groupableColumnIds;
+    return visibleColumns.filter((col) => {
+      const id = columnId(col);
+      if (allowed) return allowed.includes(id);
+      return col.accessorKey !== void 0 || col.accessorFn !== void 0;
+    });
+  }, [visibleColumns, grouping?.groupableColumnIds]);
+  const groupedRenderRows = useMemo8(
+    () => groups ? flattenGroups(groups, collapsedGroups) : null,
+    [groups, collapsedGroups]
+  );
+  const virtualizeConfig = virtualize === void 0 || virtualize === false ? null : virtualize === true ? {} : virtualize;
+  const virtualRowHeight = explicitRowHeight ?? virtualizeConfig?.rowHeight ?? (resolvedDensity === "condensed" ? 32 : resolvedDensity === "spacious" ? 52 : 40);
+  const virtualThreshold = virtualizeConfig?.threshold ?? 150;
+  const bodyEntryCount = groupedRenderRows ? groupedRenderRows.length : paginated.length;
+  const virtualizeActive = virtualizeConfig !== null && virtualizeConfig.enabled !== false && bodyEntryCount > virtualThreshold && !hierarchy && expandedDetail === void 0;
+  const columnWindowWidth = virtualizeConfig?.columnWidth ?? 160;
+  const frozenRunLength = useMemo8(() => {
+    let run = 0;
+    for (const col of visibleColumns) {
+      if (frozenColumns.offsets[columnId(col)] === void 0) break;
+      run += 1;
+    }
+    return run;
+  }, [visibleColumns, frozenColumns]);
+  const columnVirtualizeActive = virtualizeConfig !== null && virtualizeConfig.enabled !== false && virtualizeConfig.columns === true && visibleColumns.length - frozenRunLength > 30 && !hierarchy && mobileCards === void 0;
+  const [rowWindow, setRowWindow] = useState22(null);
+  const [columnWindow, setColumnWindow] = useState22(null);
+  const windowInputs = useRef15({
+    virtualizeActive: false,
+    bodyEntryCount: 0,
+    virtualRowHeight: 40,
+    overscan: 8,
+    columnVirtualizeActive: false,
+    columnCount: 0,
+    columnWindowWidth: 160,
+    frozenRunLength: 0
+  });
+  windowInputs.current = {
+    virtualizeActive,
+    bodyEntryCount,
+    virtualRowHeight,
+    overscan: virtualizeConfig?.overscan ?? 8,
+    columnVirtualizeActive,
+    columnCount: visibleColumns.length,
+    columnWindowWidth,
+    frozenRunLength
+  };
+  const recomputeWindows = useCallback8(() => {
+    const el = scrollRef.current;
+    const input = windowInputs.current;
+    const nextRow = input.virtualizeActive ? computeWindow({
+      count: input.bodyEntryCount,
+      itemSize: input.virtualRowHeight,
+      viewport: el?.clientHeight || 600,
+      offset: el?.scrollTop ?? 0,
+      overscan: input.overscan
+    }) : null;
+    const nextColumn = input.columnVirtualizeActive ? computeWindow({
+      count: input.columnCount,
+      itemSize: input.columnWindowWidth,
+      viewport: el?.clientWidth || 1200,
+      offset: el?.scrollLeft ?? 0,
+      overscan: Math.max(2, Math.round(input.overscan / 2)),
+      pinnedStart: input.frozenRunLength
+    }) : null;
+    setRowWindow((prev) => sameWindow(prev, nextRow) ? prev : nextRow);
+    setColumnWindow((prev) => sameWindow(prev, nextColumn) ? prev : nextColumn);
+  }, []);
+  const effectiveRowWindow = useMemo8(() => {
+    if (!virtualizeActive) return null;
+    if (rowWindow && rowWindow.end <= bodyEntryCount) return rowWindow;
+    return computeWindow({
+      count: bodyEntryCount,
+      itemSize: virtualRowHeight,
+      viewport: scrollRef.current?.clientHeight || 600,
+      offset: scrollRef.current?.scrollTop ?? 0,
+      overscan: virtualizeConfig?.overscan ?? 8
+    });
+  }, [virtualizeActive, rowWindow, bodyEntryCount, virtualRowHeight, virtualizeConfig?.overscan]);
+  const effectiveColumnWindow = useMemo8(() => {
+    if (!columnVirtualizeActive) return null;
+    if (columnWindow && columnWindow.end <= visibleColumns.length) return columnWindow;
+    return computeWindow({
+      count: visibleColumns.length,
+      itemSize: columnWindowWidth,
+      viewport: scrollRef.current?.clientWidth || 1200,
+      offset: scrollRef.current?.scrollLeft ?? 0,
+      overscan: Math.max(2, Math.round((virtualizeConfig?.overscan ?? 8) / 2)),
+      pinnedStart: frozenRunLength
+    });
+  }, [
+    columnVirtualizeActive,
+    columnWindow,
+    visibleColumns.length,
+    columnWindowWidth,
+    virtualizeConfig?.overscan,
+    frozenRunLength
+  ]);
+  const metricsWanted = virtualizeActive || columnVirtualizeActive;
+  useEffect16(() => {
+    recomputeWindows();
+  }, [
+    recomputeWindows,
+    virtualizeActive,
+    bodyEntryCount,
+    virtualRowHeight,
+    columnVirtualizeActive,
+    visibleColumns.length,
+    columnWindowWidth,
+    frozenRunLength
+  ]);
+  useEffect16(() => {
+    if (!metricsWanted) return;
+    const el = scrollRef.current;
+    if (!el) return;
+    let frame = 0;
+    const onScroll = () => {
+      if (frame) return;
+      frame = requestAnimationFrame(() => {
+        frame = 0;
+        recomputeWindows();
+      });
+    };
+    el.addEventListener("scroll", onScroll, { passive: true });
+    const observer = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(onScroll);
+    observer?.observe(el);
+    return () => {
+      if (frame) cancelAnimationFrame(frame);
+      el.removeEventListener("scroll", onScroll);
+      observer?.disconnect();
+    };
+  }, [metricsWanted, recomputeWindows]);
+  const renderedColumns = useMemo8(
+    () => effectiveColumnWindow ? [
+      ...visibleColumns.slice(0, frozenRunLength),
+      ...visibleColumns.slice(effectiveColumnWindow.start, effectiveColumnWindow.end)
+    ] : visibleColumns,
+    [effectiveColumnWindow, visibleColumns, frozenRunLength]
+  );
+  const columnSpacers = effectiveColumnWindow ? { start: effectiveColumnWindow.padStart, end: effectiveColumnWindow.padEnd } : null;
+  const windowedWidthFor = useCallback8(
+    (id, declared) => {
+      const resized = effectiveColumnWidths[id];
+      if (!effectiveColumnWindow) return resized;
+      if (frozenColumns.offsets[id] !== void 0) return resized;
+      return resized ?? (typeof declared === "number" ? declared : columnWindowWidth);
+    },
+    [effectiveColumnWindow, effectiveColumnWidths, frozenColumns, columnWindowWidth]
+  );
+  const coverageResult = useMemo8(() => {
+    if (!coverage) return null;
+    return describeCoverage({
+      loaded: processed.length,
+      ...coverage.matched === void 0 ? {} : { matched: coverage.matched },
+      ...coverage.total === void 0 ? {} : { total: coverage.total },
+      ...coverage.cap === void 0 ? {} : { cap: coverage.cap },
+      answeredBy: coverage.answeredBy ?? "client",
+      ...coverage.noun === void 0 ? {} : { noun: coverage.noun }
+    });
+  }, [coverage, processed.length]);
+  const bodyEntries = useMemo8(() => {
+    const from = effectiveRowWindow ? effectiveRowWindow.start : 0;
+    const to = effectiveRowWindow ? effectiveRowWindow.end : void 0;
+    const windowed = groupedRenderRows ? groupedRenderRows.slice(from, to).map(
+      (entry) => entry.kind === "group" ? {
+        kind: "group",
+        group: entry.group,
+        collapsed: isGroupCollapsed(collapsedGroups, entry.group.key)
+      } : { kind: "row", row: entry.row, index: entry.dataIndex ?? 0 }
+    ) : paginated.slice(from, to).map((row, offset) => ({ kind: "row", row, index: from + offset }));
+    if (!effectiveRowWindow) return windowed;
+    if (effectiveRowWindow.padStart > 0)
+      windowed.unshift({ kind: "spacer", height: effectiveRowWindow.padStart, place: "start" });
+    if (effectiveRowWindow.padEnd > 0)
+      windowed.push({ kind: "spacer", height: effectiveRowWindow.padEnd, place: "end" });
+    return windowed;
+  }, [groupedRenderRows, collapsedGroups, paginated, effectiveRowWindow]);
+  const getRowIdRef = useRef15(getRowId);
+  getRowIdRef.current = getRowId;
+  const spreadsheetRowIds = useMemo8(
+    () => paginated.map((row) => getRowIdRef.current(row)),
+    [paginated]
+  );
+  const spreadsheetColumnIds = useMemo8(
+    () => visibleColumns.map((col) => columnId(col)),
+    [visibleColumns]
+  );
+  const spreadsheetRowById = useMemo8(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const row of paginated) map.set(getRowIdRef.current(row), row);
+    return map;
+  }, [paginated]);
+  const spreadsheetColumnById = useMemo8(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const col of visibleColumns) map.set(columnId(col), col);
+    return map;
+  }, [visibleColumns]);
+  const spreadsheetEnabled = Boolean(spreadsheet && spreadsheet.enabled !== false);
+  const sheet = useSpreadsheetGrid(
+    spreadsheetEnabled && spreadsheet ? {
+      rowIds: spreadsheetRowIds,
+      columnIds: spreadsheetColumnIds,
+      valueAt: (rowId, colId) => {
+        const row = spreadsheetRowById.get(rowId);
+        const col = spreadsheetColumnById.get(colId);
+        if (row === void 0 || col === void 0) return null;
+        if (spreadsheet.readCell) return spreadsheet.readCell(row, colId);
+        return getCellValue(applyRowEdits(row, edits[rowId]), col);
+      },
+      isColumnWritable: (colId) => {
+        if (spreadsheet.writableColumnIds) return spreadsheet.writableColumnIds.includes(colId);
+        const col = spreadsheetColumnById.get(colId);
+        return Boolean(col && col.editable);
+      },
+      ...spreadsheet.columnRefusal ? { columnRefusal: spreadsheet.columnRefusal } : {},
+      onPatch: spreadsheet.onPatch,
+      ...spreadsheet.undoDepth === void 0 ? {} : { undoDepth: spreadsheet.undoDepth },
+      ...spreadsheet.fillHandle === void 0 ? {} : { fillHandle: spreadsheet.fillHandle },
+      ...spreadsheet.paste === void 0 ? {} : { paste: spreadsheet.paste },
+      notify: spreadsheet.notify ?? ((message) => toast.success(message)),
+      onEditRequest: (address, seed) => requestCellEditRef.current(address, seed),
+      ...spreadsheet.validateCell ? { validateCell: spreadsheet.validateCell } : {}
+    } : null
+  );
+  const sheetRef = useRef15(sheet);
+  sheetRef.current = sheet;
+  const searchValueRef = useRef15(searchValue);
+  searchValueRef.current = searchValue;
+  const facetsEnabled = Boolean(facets && facets.enabled !== false);
+  const [facetState, setFacetState] = useState22({});
+  const facetReadCell = useCallback8(
+    (row, colId) => {
+      if (facets?.readCell) return facets.readCell(row, colId);
+      const col = visibleColumns.find((candidate) => columnId(candidate) === colId);
+      return col ? getFilterValue(row, col) : void 0;
+    },
+    [facets, visibleColumns]
+  );
+  const facetInputsRef = useRef15({ data, facets, facetReadCell });
+  facetInputsRef.current = { data, facets, facetReadCell };
+  const facetRequestRef = useRef15(/* @__PURE__ */ new Map());
+  const requestFacets = useCallback8((colId) => {
+    const { data: rows, facets: config, facetReadCell: readCell } = facetInputsRef.current;
+    if (!config || config.enabled === false) return;
+    const complete = localFacetsAreComplete(rows.length, config.totalRows);
+    const limit = config.limit;
+    if (complete || !config.source) {
+      setFacetState((current) => ({
+        ...current,
+        [colId]: {
+          loading: false,
+          data: computeColumnFacets({
+            columnId: colId,
+            rows,
+            readValue: readCell,
+            ...limit === void 0 ? {} : { limit },
+            complete
+          })
+        }
+      }));
+      return;
+    }
+    const ticket = (facetRequestRef.current.get(colId) ?? 0) + 1;
+    facetRequestRef.current.set(colId, ticket);
+    setFacetState((current) => ({
+      ...current,
+      [colId]: { loading: true, data: current[colId]?.data ?? null }
+    }));
+    void Promise.resolve().then(
+      () => config.source?.({ columnId: colId, search: searchValueRef.current, limit: limit ?? 200 })
+    ).then((answer) => {
+      if (facetRequestRef.current.get(colId) !== ticket) return;
+      if (!answer) {
+        setFacetState((current) => ({
+          ...current,
+          [colId]: {
+            loading: false,
+            data: computeColumnFacets({
+              columnId: colId,
+              rows: facetInputsRef.current.data,
+              readValue: facetInputsRef.current.facetReadCell,
+              ...limit === void 0 ? {} : { limit },
+              complete: false
+            })
+          }
+        }));
+        return;
+      }
+      setFacetState((current) => ({
+        ...current,
+        [colId]: { loading: false, data: { ...answer, answeredBy: "source", complete: true } }
+      }));
+    }).catch((error) => {
+      if (facetRequestRef.current.get(colId) !== ticket) return;
+      setFacetState((current) => ({
+        ...current,
+        [colId]: { loading: false, data: null, error: describeFacetFailure(error) }
+      }));
+    });
+  }, []);
+  useEffect16(() => {
+    if (!facetsEnabled) return;
+    setFacetState({});
+    facetRequestRef.current = /* @__PURE__ */ new Map();
+  }, [facetsEnabled, data, searchValue]);
+  useEffect16(() => {
     if (!controlledQuery || controlledQuery.state.page === safePage) return;
     emitControlledQueryChange({ page: safePage });
   }, [controlledQuery, emitControlledQueryChange, safePage]);
-  const selectedRow = useMemo7(() => {
+  const selectedRow = useMemo8(() => {
     if (!selectedId) return null;
     return data.find((r) => getRowId(r) === selectedId) ?? null;
   }, [data, selectedId, getRowId]);
-  const windowRow = useMemo7(() => {
+  const windowRow = useMemo8(() => {
     if (!windowRowId) return null;
     return data.find((r) => getRowId(r) === windowRowId) ?? (windowRowSnapshot && windowRowSnapshot.queryKey === appendQueryKey && getRowId(windowRowSnapshot.row) === windowRowId ? windowRowSnapshot.row : null);
   }, [data, windowRowId, windowRowSnapshot, getRowId, appendQueryKey]);
@@ -10718,12 +13006,12 @@ function MatrxDataTableCore({
     return def !== void 0 && f.value !== def;
   });
   const hasActiveFilters = activeFilterCount > 0 || Boolean(searchValue.trim()) || intelligentSearchEnabled && searchScope !== "all" || Boolean(anyOfValue.trim()) || completeLayeredFilterRules(layeredFilters).length > 0 || facetActive;
-  const changeCount = useMemo7(() => {
-    let n = 0;
+  const changeCount = useMemo8(() => {
+    let n2 = 0;
     for (const fields of Object.values(edits)) {
-      n += Object.keys(fields).length;
+      n2 += Object.keys(fields).length;
     }
-    return n;
+    return n2;
   }, [edits]);
   const showSearch = toolbar?.search !== false;
   const openDetail = (row) => {
@@ -10802,6 +13090,23 @@ function MatrxDataTableCore({
     icon: void 0
   } : emptyState;
   const commitCell = (rowId, field, next) => {
+    if (edit?.validate) {
+      const row = data.find((candidate) => getRowId(candidate) === rowId);
+      if (row) {
+        let refusal;
+        try {
+          refusal = edit.validate({
+            row: applyRowEdits(row, edits[rowId]),
+            rowId,
+            columnId: field,
+            value: next
+          });
+        } catch {
+          refusal = void 0;
+        }
+        if (refusal) return refusal;
+      }
+    }
     const scope = editScopeKey;
     const nextEdits = { [rowId]: { [field]: next } };
     const revision = setCellEdit(rowId, field, next);
@@ -10846,9 +13151,29 @@ function MatrxDataTableCore({
     setEditRequest((current) => ({
       rowId: getRowId(row),
       field,
-      nonce: (current?.nonce ?? 0) + 1
+      nonce: (current?.nonce ?? 0) + 1,
+      seed: null
+    }));
+  };
+  const requestCellEdit = (address, seed) => {
+    if (!editEnabled) return false;
+    const row = data.find((candidate) => getRowId(candidate) === address.rowId);
+    if (!row) return false;
+    const column = visibleColumns.find(
+      (candidate) => columnId(candidate) === address.fieldName
+    );
+    if (!column?.editable || !(column.editableIf?.(row) ?? true)) return false;
+    const field = column.accessorKey ? String(column.accessorKey) : columnId(column);
+    setEditRequest((current) => ({
+      rowId: address.rowId,
+      field,
+      nonce: (current?.nonce ?? 0) + 1,
+      seed
     }));
+    return true;
   };
+  const requestCellEditRef = useRef15(requestCellEdit);
+  requestCellEditRef.current = requestCellEdit;
   const buildRecordControls = (row) => {
     const rowId = getRowId(row);
     const pending = edits[rowId];
@@ -10874,7 +13199,7 @@ function MatrxDataTableCore({
   };
   const hierarchyRows = hierarchy?.rows ?? data;
   const hierarchyGetParentId = hierarchy?.getParentId;
-  const hierarchyIndex = useMemo7(() => {
+  const hierarchyIndex = useMemo8(() => {
     if (!hierarchyGetParentId) return null;
     const byId = /* @__PURE__ */ new Map();
     const parentById = /* @__PURE__ */ new Map();
@@ -10906,7 +13231,7 @@ function MatrxDataTableCore({
     return { byId, parentById, depthById };
   }, [hierarchyGetParentId, hierarchyRows, getRowId]);
   const draggedRow = draggedRowId && hierarchyIndex ? hierarchyIndex.byId.get(draggedRowId) : void 0;
-  const hierarchyBlockedIds = useMemo7(() => {
+  const hierarchyBlockedIds = useMemo8(() => {
     if (!draggedRowId || !hierarchyIndex) return null;
     const childrenById = /* @__PURE__ */ new Map();
     for (const [id, parentId] of hierarchyIndex.parentById) {
@@ -11089,19 +13414,80 @@ function MatrxDataTableCore({
     setEdits({});
     edit?.onCancel?.();
   };
-  useEffect15(() => {
-    if (!host.rowContextRegistry || !contextMenu && !host.createDefaultRowContext) return;
-    return host.rowContextRegistry.register(tableContextMenuInstanceId, (rowId) => {
+  const resolveMenuLevel = (target) => {
+    const rowFor = (rowId) => {
       const row = data.find((candidate) => getRowId(candidate) === rowId);
       if (!row) return null;
-      const pending = edits[rowId];
-      const displayRow = applyRowEdits(row, pending);
-      const controls = buildRecordControls(displayRow);
-      return contextMenu?.resolveRowContext(displayRow, controls) ?? host.createDefaultRowContext?.(displayRow, controls) ?? null;
-    });
-  }, [buildRecordControls, contextMenu, data, getRowId, host.createDefaultRowContext, host.rowContextRegistry, tableContextMenuInstanceId]);
+      return applyRowEdits(row, edits[rowId]);
+    };
+    const columnFor = (id) => visibleColumns.find((col) => columnId(col) === id);
+    const labelFor = (col, id) => col?.label ?? (typeof col?.header === "string" ? col.header : id);
+    const fromHost = (payload) => host.createDefaultMenuContext?.(payload) ?? null;
+    switch (target.level) {
+      case "row": {
+        if (!target.rowId) return null;
+        const displayRow = rowFor(target.rowId);
+        if (!displayRow) return null;
+        const controls = buildRecordControls(displayRow);
+        return contextMenu?.resolveRowContext?.(displayRow, controls) ?? fromHost({ level: "row", row: displayRow, rowId: target.rowId, controls });
+      }
+      case "cell": {
+        if (!target.rowId || !target.columnId) return null;
+        const displayRow = rowFor(target.rowId);
+        const col = columnFor(target.columnId);
+        if (!displayRow || !col) return null;
+        const controls = buildRecordControls(displayRow);
+        const value = spreadsheet?.readCell ? spreadsheet.readCell(displayRow, target.columnId) : getCellValue(displayRow, col);
+        const args = {
+          row: displayRow,
+          rowId: target.rowId,
+          columnId: target.columnId,
+          columnLabel: labelFor(col, target.columnId),
+          value,
+          text: stringifyCellValue(value),
+          controls
+        };
+        return contextMenu?.resolveCellContext?.(args) ?? fromHost({ level: "cell", ...args });
+      }
+      case "column": {
+        if (!target.columnId) return null;
+        const col = columnFor(target.columnId);
+        if (!col) return null;
+        const args = {
+          columnId: target.columnId,
+          columnLabel: labelFor(col, target.columnId),
+          values: paginated.map(
+            (row) => getCellValue(applyRowEdits(row, edits[getRowId(row)]), col)
+          )
+        };
+        return contextMenu?.resolveColumnContext?.(args) ?? fromHost({ level: "column", ...args });
+      }
+      case "selection": {
+        const addresses = sheetRef.current.selectionAddresses();
+        const cellCount = addresses.rowIds.length * addresses.columnIds.length;
+        if (cellCount <= 1) {
+          return resolveMenuLevel({ ...target, level: "cell" });
+        }
+        const args = { ...addresses, tsv: sheetRef.current.selectionTsv(), cellCount };
+        return contextMenu?.resolveSelectionContext?.(args) ?? fromHost({ level: "selection", ...args });
+      }
+      case "table": {
+        const args = { rowCount: data.length, columnIds: visibleColumns.map((col) => columnId(col)) };
+        return contextMenu?.resolveTableContext?.(args) ?? fromHost({ level: "table", ...args });
+      }
+    }
+  };
+  const resolveMenuLevelRef = useRef15(resolveMenuLevel);
+  resolveMenuLevelRef.current = resolveMenuLevel;
+  useEffect16(() => {
+    if (!host.rowContextRegistry) return;
+    return host.rowContextRegistry.register(
+      tableContextMenuInstanceId,
+      (target) => resolveMenuLevelRef.current(target)
+    );
+  }, [host.rowContextRegistry, tableContextMenuInstanceId]);
   const showActionsCol = windowEnabled || Boolean(rowActions) || showInlineRowCopy;
-  const selectedIdSet = useMemo7(
+  const selectedIdSet = useMemo8(
     () => new Set(selection?.selectedIds ?? []),
     [selection?.selectedIds]
   );
@@ -11113,11 +13499,11 @@ function MatrxDataTableCore({
   );
   const allOnPageSelected = selectableRows.length > 0 && selectedOnPage.length === selectableRows.length;
   const someOnPageSelected = selectedOnPage.length > 0 && !allOnPageSelected;
-  const selectedRows = useMemo7(
+  const selectedRows = useMemo8(
     () => data.filter((row) => selectedIdSet.has(getRowId(row))),
     [data, selectedIdSet, getRowId]
   );
-  const lastToggledIndex = useRef13(null);
+  const lastToggledIndex = useRef15(null);
   const setSelectedIds = (next) => selection?.onSelectedIdsChange([...next]);
   const toggleRowSelected = (index, shiftKey) => {
     if (!selection) return;
@@ -11154,6 +13540,7 @@ function MatrxDataTableCore({
   const selectionNoun = selection?.noun ?? "row";
   const selectionCount = selection?.selectedIds.length ?? 0;
   const leadingCols = selection ? 1 : 0;
+  const renderedColSpan = renderedColumns.length + leadingCols + (showActionsCol ? 1 : 0) + (columnSpacers ? (columnSpacers.start > 0 ? 1 : 0) + (columnSpacers.end > 0 ? 1 : 0) : 0);
   const renderedFacets = controlledQuery ? toolbar?.facets?.map(
     (facet) => facet.type === "button-group" ? {
       ...facet,
@@ -11180,14 +13567,25 @@ function MatrxDataTableCore({
           dirty: Boolean(rowEdits && field in rowEdits),
           onCommit: (next) => commitCell(id, field, next),
           ...href === void 0 ? {} : { href },
-          ...col.editTrigger === void 0 ? {} : { editTrigger: col.editTrigger },
-          ...editRequest?.rowId === id && editRequest.field === field ? { editRequest: editRequest.nonce } : {}
+          ...spreadsheetEnabled ? {
+            // 🚨 THE CLICK LAW, enforced where the two paths meet. In a grid
+            // with spreadsheet gestures a single click SELECTS a cell — it
+            // may never drop a person into a free-text buffer, because the
+            // same click is how they start a range, and an editor that opens
+            // under the pointer eats the drag and the next keystroke. So the
+            // editor opens the way it does in Excel: Enter, F2, the hover
+            // pencil, or simply typing. An explicit `editTrigger: "click"`
+            // does not override this; the law is the table's, not the
+            // column's.
+            editTrigger: "pencil"
+          } : col.editTrigger === void 0 ? {} : { editTrigger: col.editTrigger },
+          ...editRequest?.rowId === id && editRequest.field === field ? { editRequest: editRequest.nonce, editSeed: editRequest.seed } : {}
         }
       );
     }
     return href ? /* @__PURE__ */ jsx42(Link, { href, onClick: (event) => event.stopPropagation(), className: "block w-full min-w-0 rounded outline-none focus-visible:ring-2 focus-visible:ring-ring", children: display }) : display;
   };
-  const currentViewSnapshot = useMemo7(
+  const currentViewSnapshot = useMemo8(
     () => ({
       __kind: "matrx-table-view",
       version: 1,
@@ -11222,7 +13620,7 @@ function MatrxDataTableCore({
       sort
     ]
   );
-  const declaredDefaultViewSnapshot = useMemo7(
+  const declaredDefaultViewSnapshot = useMemo8(
     () => defaultViewSnapshot ?? {
       __kind: "matrx-table-view",
       version: 1,
@@ -11241,7 +13639,7 @@ function MatrxDataTableCore({
     },
     [columns, defaultPageSize, defaultSort, defaultViewSnapshot]
   );
-  const applySavedView = useCallback7(
+  const applySavedView = useCallback8(
     (rawSnapshot) => {
       const snapshot = parseTableViewSnapshot(rawSnapshot);
       if (!snapshot) {
@@ -11593,6 +13991,28 @@ function MatrxDataTableCore({
                               }
                             }
                           ) : null,
+                          grouping?.onColumnIdChange ? /* @__PURE__ */ jsxs32(
+                            Select,
+                            {
+                              value: groupingColumnId ?? NO_GROUPING_VALUE,
+                              onValueChange: (value) => grouping.onColumnIdChange?.(value === NO_GROUPING_VALUE ? null : value),
+                              children: [
+                                /* @__PURE__ */ jsx42(
+                                  SelectTrigger,
+                                  {
+                                    "data-matrx-table-group-by": true,
+                                    "aria-label": "Group rows by a column",
+                                    className: "h-8 w-auto min-w-[9rem] gap-1 text-xs",
+                                    children: /* @__PURE__ */ jsx42(SelectValue, { placeholder: "No groups" })
+                                  }
+                                ),
+                                /* @__PURE__ */ jsxs32(SelectContent, { children: [
+                                  /* @__PURE__ */ jsx42(SelectItem, { value: NO_GROUPING_VALUE, children: "No groups" }),
+                                  groupableColumns.map((col) => /* @__PURE__ */ jsx42(SelectItem, { value: columnId(col), children: `Group by ${col.label ?? (typeof col.header === "string" ? col.header : columnId(col))}` }, columnId(col)))
+                                ] })
+                              ]
+                            }
+                          ) : null,
                           columns.length > 0 ? /* @__PURE__ */ jsx42(
                             TableToolbarAction,
                             {
@@ -11660,65 +14080,6 @@ function MatrxDataTableCore({
                   ]
                 }
               ),
-              selection && selectionCount > 0 ? /* @__PURE__ */ jsxs32("div", { className: "flex shrink-0 flex-wrap items-center gap-2 rounded-md border border-primary/30 bg-primary/5 px-2 py-1.5", children: [
-                /* @__PURE__ */ jsxs32("span", { className: "text-xs font-medium text-foreground", children: [
-                  formatCount3(selectionCount),
-                  " ",
-                  selectionNoun,
-                  selectionCount === 1 ? "" : "s",
-                  " selected"
-                ] }),
-                /* @__PURE__ */ jsxs32(
-                  Button,
-                  {
-                    type: "button",
-                    variant: "ghost",
-                    size: "sm",
-                    className: "h-7 gap-1 px-2 text-xs",
-                    onClick: () => {
-                      lastToggledIndex.current = null;
-                      selection.onSelectedIdsChange([]);
-                    },
-                    children: [
-                      /* @__PURE__ */ jsx42(X, { className: "h-3.5 w-3.5" }),
-                      "Clear"
-                    ]
-                  }
-                ),
-                /* @__PURE__ */ jsxs32("div", { className: "ml-auto flex flex-wrap items-center gap-1.5", children: [
-                  effectiveCopy && selectedRows.length > 0 ? /* @__PURE__ */ jsx42(
-                    CopyButtons,
-                    {
-                      size: "icon",
-                      "data-matrx-table-icon-action": true,
-                      sourceId: `${tableCopySourceNamespace}:selection`,
-                      ...effectiveCopy.references ? { references: effectiveCopy.references(selectedRows, data) } : {},
-                      ...effectiveCopy.triggerVariant ? { triggerVariant: effectiveCopy.triggerVariant } : {},
-                      label: `${selectedRows.length} selected ${selectionNoun}${selectedRows.length === 1 ? "" : "s"}`,
-                      ...copy === void 0 ? {} : {
-                        human: () => buildViewHuman(effectiveCopy, selectedRows, effectiveCopyColumns),
-                        json: () => selectedRows.map((row) => effectiveCopy.agentRow ? effectiveCopy.agentRow(row) : row)
-                      },
-                      agent: () => copy === void 0 ? buildDefaultTableViewAgentInput(effectiveCopy, selectedRows, data, declaredVisibleCopyColumns, { scope: "selected" }) : buildViewAgentInput(effectiveCopy, selectedRows, data, { scope: "selected" }),
-                      aiVariants: copySubsetVariantFor(
-                        () => selectedRows,
-                        "selected"
-                      ),
-                      export: {
-                        items: [],
-                        sheetRows: () => selectedRows.map(
-                          (row) => projectDefaultTableCopyRow(row, declaredVisibleCopyColumns)
-                        ),
-                        sheetColumns: () => declaredVisibleCopyColumns.map((column) => ({
-                          id: columnId(column),
-                          label: column.label ?? (typeof column.header === "string" ? column.header : columnId(column))
-                        }))
-                      }
-                    }
-                  ) : null,
-                  selection.actions?.(selectedRows, selection.selectedIds)
-                ] })
-              ] }) : null,
               /* @__PURE__ */ jsxs32("div", { "data-matrx-table-body-region": true, className: "flex min-h-0 flex-1 flex-col gap-2", children: [
                 /* @__PURE__ */ jsxs32("div", { className: "relative min-h-0 flex-1", children: [
                   mobileCards ? /* @__PURE__ */ jsxs32(
@@ -11826,12 +14187,33 @@ function MatrxDataTableCore({
                       ]
                     }
                   ) : null,
+                  coverageResult && coverageResult.notice ? /* @__PURE__ */ jsxs32(
+                    "div",
+                    {
+                      "data-matrx-table-coverage": true,
+                      "data-matrx-table-coverage-scope": coverageResult.scope,
+                      role: "status",
+                      className: "mb-1 flex items-start gap-2 rounded-md border border-amber-300/70 bg-amber-50 px-3 py-2 text-xs text-amber-900 dark:border-amber-500/40 dark:bg-amber-950/40 dark:text-amber-200",
+                      children: [
+                        /* @__PURE__ */ jsx42("span", { className: "font-semibold", children: coverageResult.badge }),
+                        /* @__PURE__ */ jsx42("span", { children: coverageResult.notice })
+                      ]
+                    }
+                  ) : null,
                   /* @__PURE__ */ jsxs32(
                     "div",
                     {
                       ref: scrollRef,
                       "data-matrx-table-scroll": true,
                       onScroll: updateScrollHint,
+                      ...spreadsheetEnabled ? {
+                        tabIndex: sheet.containerProps.tabIndex,
+                        onKeyDown: sheet.containerProps.onKeyDown,
+                        onCopy: sheet.containerProps.onCopy,
+                        onCut: sheet.containerProps.onCut,
+                        onPaste: sheet.containerProps.onPaste,
+                        "data-matrx-table-spreadsheet": "true"
+                      } : {},
                       "aria-busy": isLoading || isFetching,
                       style: { containerType: "inline-size" },
                       className: cn(
@@ -11889,7 +14271,14 @@ function MatrxDataTableCore({
                                   ref: tableHeaderRef,
                                   "data-matrx-table-sticky-header": stickyHeader ? "true" : void 0,
                                   className: cn(
-                                    "z-10 border-b border-border bg-muted/90 shadow-[0_1px_0_0_var(--border)] backdrop-blur-sm",
+                                    // 🚨 ABOVE THE FROZEN COLUMN, NOT UNDER IT. A frozen body
+                                    // cell is `sm:z-20` so it can slide under the columns to
+                                    // its right; the header was `z-10`, so the frozen column's
+                                    // cells scrolled straight OVER the header they belong to
+                                    // and the top data row printed through the column names.
+                                    // Only a table long enough to scroll shows it, which is why
+                                    // it survived until a hundred-thousand-row screenshot.
+                                    "z-30 border-b border-border bg-muted/90 shadow-[0_1px_0_0_var(--border)] backdrop-blur-sm",
                                     stickyHeader && (documentStickyHeader ? "relative translate-y-[var(--matrx-document-sticky-offset)]" : "sticky top-0")
                                   ),
                                   children: /* @__PURE__ */ jsxs32("tr", { children: [
@@ -11922,7 +14311,17 @@ function MatrxDataTableCore({
                                         )
                                       }
                                     ) : null,
-                                    visibleColumns.map((col) => {
+                                    columnSpacers && columnSpacers.start > 0 ? /* @__PURE__ */ jsx42(
+                                      "th",
+                                      {
+                                        "aria-hidden": "true",
+                                        "data-matrx-table-column-spacer": "start",
+                                        className: "border-0 p-0",
+                                        style: { width: `${columnSpacers.start}px`, minWidth: `${columnSpacers.start}px` }
+                                      },
+                                      "matrx-column-spacer-start"
+                                    ) : null,
+                                    renderedColumns.map((col) => {
                                       const id = columnId(col);
                                       const meta = filterMeta.get(id);
                                       const isSorted = sort?.id === id;
@@ -11938,6 +14337,7 @@ function MatrxDataTableCore({
                                         "th",
                                         {
                                           "data-matrx-table-column-id": id,
+                                          "data-matrx-header-column-id": id,
                                           "data-matrx-column-drag-shadow": isColumnDragShadow ? "true" : void 0,
                                           "aria-sort": isSorted ? sort?.direction === "asc" ? "ascending" : "descending" : void 0,
                                           className: cn(
@@ -11965,7 +14365,7 @@ function MatrxDataTableCore({
                                             frozenEdgeId === id && FROZEN_EDGE_CLASS
                                           ),
                                           style: {
-                                            ...columnWidthVar(width, effectiveColumnWidths[id], id, columnResizable),
+                                            ...columnWidthVar(width, windowedWidthFor(id, width), id, columnResizable),
                                             ...frozenStyle(id)
                                           },
                                           children: [
@@ -11974,6 +14374,12 @@ function MatrxDataTableCore({
                                               {
                                                 label: col.header,
                                                 labelText: headerLabel,
+                                                ...facetsEnabled ? {
+                                                  facets: facetState[id]?.data ?? null,
+                                                  facetsLoading: facetState[id]?.loading ?? false,
+                                                  ...facetState[id]?.error === void 0 ? {} : { facetsError: facetState[id]?.error },
+                                                  onFilterOpen: () => requestFacets(id)
+                                                } : {},
                                                 sortable: col.sortable !== false,
                                                 isSorted: Boolean(isSorted),
                                                 sortDirection: sort?.direction ?? defaultSortDirection,
@@ -12029,6 +14435,16 @@ function MatrxDataTableCore({
                                         id
                                       );
                                     }),
+                                    columnSpacers && columnSpacers.end > 0 ? /* @__PURE__ */ jsx42(
+                                      "th",
+                                      {
+                                        "aria-hidden": "true",
+                                        "data-matrx-table-column-spacer": "end",
+                                        className: "border-0 p-0",
+                                        style: { width: `${columnSpacers.end}px`, minWidth: `${columnSpacers.end}px` }
+                                      },
+                                      "matrx-column-spacer-end"
+                                    ) : null,
                                     showActionsCol && /* @__PURE__ */ jsx42(
                                       "th",
                                       {
@@ -12044,7 +14460,17 @@ function MatrxDataTableCore({
                               /* @__PURE__ */ jsxs32("tbody", { children: [
                                 isLoading ? Array.from({ length: 6 }).map((_, i) => /* @__PURE__ */ jsxs32("tr", { className: "border-b border-border/60", children: [
                                   selection ? /* @__PURE__ */ jsx42("td", { className: "px-2 py-2", style: fixedUtilityWidth(fixedTableGeometry?.selectionWidth), children: /* @__PURE__ */ jsx42(Skeleton, { className: "h-3.5 w-3.5" }) }) : null,
-                                  visibleColumns.map((col) => /* @__PURE__ */ jsx42(
+                                  columnSpacers && columnSpacers.start > 0 ? /* @__PURE__ */ jsx42(
+                                    "td",
+                                    {
+                                      "aria-hidden": "true",
+                                      "data-matrx-table-column-spacer": "start",
+                                      className: "border-0 p-0",
+                                      style: { width: `${columnSpacers.start}px`, minWidth: `${columnSpacers.start}px` }
+                                    },
+                                    "matrx-column-spacer-start"
+                                  ) : null,
+                                  renderedColumns.map((col) => /* @__PURE__ */ jsx42(
                                     "td",
                                     {
                                       className: cn(
@@ -12056,11 +14482,21 @@ function MatrxDataTableCore({
                                     },
                                     columnId(col)
                                   )),
-                                  showActionsCol && /* @__PURE__ */ jsx42("td", { className: "text-right align-middle", style: fixedUtilityWidth(fixedTableGeometry?.actionsWidth), children: /* @__PURE__ */ jsx42(Skeleton, { className: "ml-auto h-5 w-10" }) })
+                                  showActionsCol && /* @__PURE__ */ jsx42("td", { className: "text-right align-middle", style: fixedUtilityWidth(fixedTableGeometry?.actionsWidth), children: /* @__PURE__ */ jsx42(Skeleton, { className: "ml-auto h-5 w-10" }) }),
+                                  columnSpacers && columnSpacers.end > 0 ? /* @__PURE__ */ jsx42(
+                                    "td",
+                                    {
+                                      "aria-hidden": "true",
+                                      "data-matrx-table-column-spacer": "end",
+                                      className: "border-0 p-0",
+                                      style: { width: `${columnSpacers.end}px`, minWidth: `${columnSpacers.end}px` }
+                                    },
+                                    "matrx-column-spacer-end"
+                                  ) : null
                                 ] }, `sk-${i}`)) : paginated.length === 0 ? /* @__PURE__ */ jsx42("tr", { children: /* @__PURE__ */ jsx42(
                                   "td",
                                   {
-                                    colSpan: visibleColumns.length + leadingCols + (showActionsCol ? 1 : 0),
+                                    colSpan: renderedColSpan,
                                     className: "px-0 py-12 text-center",
                                     children: /* @__PURE__ */ jsxs32("div", { "data-matrx-table-empty-state": true, className: "sticky left-0 flex flex-col items-center gap-2 whitespace-normal px-4", style: { width: "100cqw", maxWidth: "100%" }, children: [
                                       renderedEmptyState?.icon,
@@ -12069,7 +14505,43 @@ function MatrxDataTableCore({
                                       renderedEmptyState?.action
                                     ] })
                                   }
-                                ) }) : paginated.map((row, index) => {
+                                ) }) : bodyEntries.map((entry) => {
+                                  if (entry.kind === "spacer") {
+                                    return /* @__PURE__ */ jsx42(
+                                      "tr",
+                                      {
+                                        "aria-hidden": "true",
+                                        "data-matrx-table-virtual-spacer": entry.place,
+                                        style: { height: `${entry.height}px` },
+                                        children: /* @__PURE__ */ jsx42(
+                                          "td",
+                                          {
+                                            className: "border-0 p-0",
+                                            colSpan: renderedColSpan
+                                          }
+                                        )
+                                      },
+                                      `matrx-virtual-spacer-${entry.place}`
+                                    );
+                                  }
+                                  if (entry.kind === "group") {
+                                    return /* @__PURE__ */ jsx42(
+                                      TableGroupHeaderRow,
+                                      {
+                                        group: entry.group,
+                                        collapsed: entry.collapsed,
+                                        columns: renderedColumns,
+                                        spacers: columnSpacers,
+                                        leadingCols,
+                                        showActionsCol,
+                                        rowNoun: grouping?.rowNoun ?? "row",
+                                        onToggle: () => setCollapsedGroups(toggleGroupCollapsed(collapsedGroups, entry.group.key))
+                                      },
+                                      `matrx-group-${entry.group.key}`
+                                    );
+                                  }
+                                  const row = entry.row;
+                                  const index = entry.index;
                                   const id = getRowId(row);
                                   const isSelected = selectedId === id;
                                   const rowEdits = edits[id];
@@ -12080,6 +14552,7 @@ function MatrxDataTableCore({
                                     "tr",
                                     {
                                       "data-row-id": id,
+                                      style: explicitRowHeight !== void 0 ? { height: `${explicitRowHeight}px` } : virtualizeActive ? { height: `${virtualRowHeight}px` } : void 0,
                                       "data-state": isSelected ? "selected" : void 0,
                                       onClick: (e) => {
                                         if (rowEventTargetsInteractiveDescendant(e.target)) return;
@@ -12152,15 +14625,40 @@ function MatrxDataTableCore({
                                             ) : null
                                           }
                                         ) : null,
-                                        visibleColumns.map((col, colIdx) => {
+                                        columnSpacers && columnSpacers.start > 0 ? /* @__PURE__ */ jsx42(
+                                          "td",
+                                          {
+                                            "aria-hidden": "true",
+                                            "data-matrx-table-column-spacer": "start",
+                                            className: "border-0 p-0",
+                                            style: { width: `${columnSpacers.start}px`, minWidth: `${columnSpacers.start}px` }
+                                          },
+                                          "matrx-column-spacer-start"
+                                        ) : null,
+                                        renderedColumns.map((col, colIdx) => {
                                           const isColumnDragShadow = columnDragPreview?.draggedId === columnId(col) && columnDragPreview.targetId !== null;
-                                          return /* @__PURE__ */ jsx42(
+                                          const sheetCell = spreadsheetEnabled ? sheet.cellProps(id, columnId(col)) : null;
+                                          const carriesFillHandle = sheetCell !== null && sheet.isFillHandleCell(id, columnId(col));
+                                          return /* @__PURE__ */ jsxs32(
                                             "td",
                                             {
                                               "data-matrx-table-column-id": columnId(col),
                                               "data-matrx-column-drag-shadow": isColumnDragShadow ? "true" : void 0,
+                                              ...sheetCell ? {
+                                                "data-matrx-cell-row": sheetCell["data-matrx-cell-row"],
+                                                "data-matrx-cell-col": sheetCell["data-matrx-cell-col"],
+                                                ...sheetCell["data-matrx-cell-selected"] ? { "data-matrx-cell-selected": "true" } : {},
+                                                ...sheetCell["data-matrx-cell-active"] ? { "data-matrx-cell-active": "true" } : {},
+                                                ...sheetCell["data-matrx-cell-fill-preview"] ? { "data-matrx-cell-fill-preview": "true" } : {},
+                                                onMouseDown: sheetCell.onMouseDown,
+                                                onMouseEnter: sheetCell.onMouseEnter
+                                              } : {},
                                               className: cn(
                                                 "py-1.5 align-middle lg:py-0.5",
+                                                sheetCell?.["data-matrx-cell-selected"] && "bg-primary/10",
+                                                sheetCell?.["data-matrx-cell-fill-preview"] && "ring-1 ring-inset ring-primary/40",
+                                                sheetCell?.["data-matrx-cell-active"] && "relative z-10 ring-2 ring-inset ring-primary",
+                                                carriesFillHandle && "relative",
                                                 col.compact || resolveColumnMarker(col) !== void 0 ? "px-1" : "px-2",
                                                 // nowrap (NOT truncate — truncate clips the cell and
                                                 // defeats w-max, killing the horizontal scroll).
@@ -12182,42 +14680,64 @@ function MatrxDataTableCore({
                                               style: {
                                                 ...columnWidthVar(
                                                   resolveColumnMarker(col) && col.width === void 0 ? 40 : col.width,
-                                                  effectiveColumnWidths[columnId(col)],
+                                                  windowedWidthFor(columnId(col), col.width),
                                                   columnId(col),
                                                   resizableColumns && col.resizable !== false
                                                 ),
                                                 ...frozenStyle(columnId(col))
                                               },
-                                              children: /* @__PURE__ */ jsxs32(
-                                                "div",
-                                                {
-                                                  className: cn(
-                                                    colIdx === 0 && hierarchy && "flex min-w-0 items-center"
-                                                  ),
-                                                  children: [
-                                                    colIdx === 0 && hierarchy ? /* @__PURE__ */ jsx42(
-                                                      HierarchyDragHandle,
-                                                      {
-                                                        id,
-                                                        label: hierarchy.itemLabel?.(row) ?? "row",
-                                                        disabled: !(hierarchy.canReparent?.(row) ?? true)
-                                                      }
-                                                    ) : null,
-                                                    /* @__PURE__ */ jsx42(
-                                                      "div",
-                                                      {
-                                                        "data-matrx-cell-content": true,
-                                                        className: "min-w-0 max-w-full flex-1 whitespace-normal break-words [overflow-wrap:anywhere] sm:[&_*]:min-w-0 sm:[&_*]:whitespace-normal sm:[&_*]:[overflow-wrap:anywhere] sm:[&_.truncate]:whitespace-nowrap sm:[&_[data-slot=badge]]:whitespace-nowrap sm:[&_[data-slot=badge]]:[overflow-wrap:normal] sm:[&_[data-matrx-cell-control]]:w-max sm:[&_[data-matrx-cell-control]]:min-w-max sm:[&_[data-matrx-cell-control]]:max-w-none sm:[&_[data-matrx-cell-control]]:whitespace-nowrap sm:[&_[data-matrx-cell-control]]:[overflow-wrap:normal] sm:[&_[data-matrx-cell-control]_*]:whitespace-nowrap sm:[&_[data-matrx-cell-control]_*]:[overflow-wrap:normal]",
-                                                        children: renderRecordCell(row, col, index)
-                                                      }
-                                                    )
-                                                  ]
-                                                }
-                                              )
+                                              children: [
+                                                /* @__PURE__ */ jsxs32(
+                                                  "div",
+                                                  {
+                                                    className: cn(
+                                                      colIdx === 0 && hierarchy && "flex min-w-0 items-center"
+                                                    ),
+                                                    children: [
+                                                      colIdx === 0 && hierarchy ? /* @__PURE__ */ jsx42(
+                                                        HierarchyDragHandle,
+                                                        {
+                                                          id,
+                                                          label: hierarchy.itemLabel?.(row) ?? "row",
+                                                          disabled: !(hierarchy.canReparent?.(row) ?? true)
+                                                        }
+                                                      ) : null,
+                                                      /* @__PURE__ */ jsx42(
+                                                        "div",
+                                                        {
+                                                          "data-matrx-cell-content": true,
+                                                          className: "min-w-0 max-w-full flex-1 whitespace-normal break-words [overflow-wrap:anywhere] sm:[&_*]:min-w-0 sm:[&_*]:whitespace-normal sm:[&_*]:[overflow-wrap:anywhere] sm:[&_.truncate]:whitespace-nowrap sm:[&_[data-slot=badge]]:whitespace-nowrap sm:[&_[data-slot=badge]]:[overflow-wrap:normal] sm:[&_[data-matrx-cell-control]]:w-max sm:[&_[data-matrx-cell-control]]:min-w-max sm:[&_[data-matrx-cell-control]]:max-w-none sm:[&_[data-matrx-cell-control]]:whitespace-nowrap sm:[&_[data-matrx-cell-control]]:[overflow-wrap:normal] sm:[&_[data-matrx-cell-control]_*]:whitespace-nowrap sm:[&_[data-matrx-cell-control]_*]:[overflow-wrap:normal]",
+                                                          children: renderRecordCell(row, col, index)
+                                                        }
+                                                      )
+                                                    ]
+                                                  }
+                                                ),
+                                                carriesFillHandle ? /* @__PURE__ */ jsx42(
+                                                  "button",
+                                                  {
+                                                    type: "button",
+                                                    "data-matrx-table-fill-handle": true,
+                                                    "aria-label": "Drag to fill the cells below or beside this selection",
+                                                    onMouseDown: sheet.startFillDrag,
+                                                    className: "absolute -bottom-[3px] -right-[3px] z-20 h-2 w-2 cursor-crosshair rounded-[1px] border border-background bg-primary"
+                                                  }
+                                                ) : null
+                                              ]
                                             },
                                             columnId(col)
                                           );
                                         }),
+                                        columnSpacers && columnSpacers.end > 0 ? /* @__PURE__ */ jsx42(
+                                          "td",
+                                          {
+                                            "aria-hidden": "true",
+                                            "data-matrx-table-column-spacer": "end",
+                                            className: "border-0 p-0",
+                                            style: { width: `${columnSpacers.end}px`, minWidth: `${columnSpacers.end}px` }
+                                          },
+                                          "matrx-column-spacer-end"
+                                        ) : null,
                                         showActionsCol && /* @__PURE__ */ jsx42(
                                           "td",
                                           {
@@ -12280,7 +14800,7 @@ function MatrxDataTableCore({
                                       children: /* @__PURE__ */ jsx42(
                                         "td",
                                         {
-                                          colSpan: visibleColumns.length + leadingCols + (showActionsCol ? 1 : 0),
+                                          colSpan: renderedColSpan,
                                           className: "p-4",
                                           children: expandedDetail.render(displayRow, controls)
                                         }
@@ -12306,7 +14826,7 @@ function MatrxDataTableCore({
                                 appendQuery !== null && isFetching && !isLoading ? /* @__PURE__ */ jsx42("tr", { "data-matrx-table-append-loading-row": true, children: /* @__PURE__ */ jsx42(
                                   "td",
                                   {
-                                    colSpan: visibleColumns.length + leadingCols + (showActionsCol ? 1 : 0),
+                                    colSpan: renderedColSpan,
                                     className: "sticky bottom-0 z-20 h-16 border-y border-border bg-card/95 px-0 py-0 text-left shadow-sm backdrop-blur-sm",
                                     children: /* @__PURE__ */ jsxs32(
                                       "div",
@@ -12331,7 +14851,17 @@ function MatrxDataTableCore({
                               ] }),
                               footerRows.length > 0 ? /* @__PURE__ */ jsx42("tfoot", { className: "border-t-2 border-border bg-muted/50 font-semibold", children: footerRows.map((row, index) => /* @__PURE__ */ jsxs32("tr", { children: [
                                 selection ? /* @__PURE__ */ jsx42("td", { className: "px-2 py-2" }) : null,
-                                visibleColumns.map((column) => /* @__PURE__ */ jsx42(
+                                columnSpacers && columnSpacers.start > 0 ? /* @__PURE__ */ jsx42(
+                                  "td",
+                                  {
+                                    "aria-hidden": "true",
+                                    "data-matrx-table-column-spacer": "start",
+                                    className: "border-0 p-0",
+                                    style: { width: `${columnSpacers.start}px`, minWidth: `${columnSpacers.start}px` }
+                                  },
+                                  "matrx-column-spacer-start"
+                                ) : null,
+                                renderedColumns.map((column) => /* @__PURE__ */ jsx42(
                                   "td",
                                   {
                                     className: cn(
@@ -12343,7 +14873,7 @@ function MatrxDataTableCore({
                                     ),
                                     style: columnWidthVar(
                                       resolveColumnMarker(column) && column.width === void 0 ? 40 : column.width,
-                                      effectiveColumnWidths[columnId(column)],
+                                      windowedWidthFor(columnId(column), column.width),
                                       columnId(column),
                                       resizableColumns && column.resizable !== false
                                     ),
@@ -12351,6 +14881,16 @@ function MatrxDataTableCore({
                                   },
                                   columnId(column)
                                 )),
+                                columnSpacers && columnSpacers.end > 0 ? /* @__PURE__ */ jsx42(
+                                  "td",
+                                  {
+                                    "aria-hidden": "true",
+                                    "data-matrx-table-column-spacer": "end",
+                                    className: "border-0 p-0",
+                                    style: { width: `${columnSpacers.end}px`, minWidth: `${columnSpacers.end}px` }
+                                  },
+                                  "matrx-column-spacer-end"
+                                ) : null,
                                 showActionsCol ? /* @__PURE__ */ jsx42("td", {}) : null
                               ] }, `footer-${index}`)) }) : null
                             ]
@@ -12514,8 +15054,8 @@ function MatrxDataTableCore({
                     itemsPerPage: pageSize === 0 && allRowsAreLoaded ? 0 : effectivePageSize,
                     currentPage: safePage,
                     onPageChange: setPage,
-                    onItemsPerPageChange: (n) => {
-                      setPageSize(n);
+                    onItemsPerPageChange: (n2) => {
+                      setPageSize(n2);
                       if (!controlledQuery) setPage(1);
                     },
                     pageSizeOptions: pageSizeOptions.filter((size) => size > 0),
@@ -12525,7 +15065,73 @@ function MatrxDataTableCore({
                     compact: true,
                     hideEntriesInfo: false
                   }
-                ) }) : null
+                ) }) : null,
+                selection && selectionCount > 0 ? /* @__PURE__ */ jsxs32(
+                  "div",
+                  {
+                    "data-matrx-table-bulk-bar": true,
+                    className: "mt-2 flex shrink-0 flex-wrap items-center gap-2 rounded-md border border-primary/30 bg-primary/5 px-2 py-1.5",
+                    children: [
+                      /* @__PURE__ */ jsxs32("span", { className: "text-xs font-medium text-foreground", children: [
+                        formatCount3(selectionCount),
+                        " ",
+                        selectionNoun,
+                        selectionCount === 1 ? "" : "s",
+                        " selected"
+                      ] }),
+                      /* @__PURE__ */ jsxs32(
+                        Button,
+                        {
+                          type: "button",
+                          variant: "ghost",
+                          size: "sm",
+                          className: "h-7 gap-1 px-2 text-xs",
+                          onClick: () => {
+                            lastToggledIndex.current = null;
+                            selection.onSelectedIdsChange([]);
+                          },
+                          children: [
+                            /* @__PURE__ */ jsx42(X, { className: "h-3.5 w-3.5" }),
+                            "Clear"
+                          ]
+                        }
+                      ),
+                      /* @__PURE__ */ jsxs32("div", { className: "ml-auto flex flex-wrap items-center gap-1.5", children: [
+                        effectiveCopy && selectedRows.length > 0 ? /* @__PURE__ */ jsx42(
+                          CopyButtons,
+                          {
+                            size: "icon",
+                            "data-matrx-table-icon-action": true,
+                            sourceId: `${tableCopySourceNamespace}:selection`,
+                            ...effectiveCopy.references ? { references: effectiveCopy.references(selectedRows, data) } : {},
+                            ...effectiveCopy.triggerVariant ? { triggerVariant: effectiveCopy.triggerVariant } : {},
+                            label: `${selectedRows.length} selected ${selectionNoun}${selectedRows.length === 1 ? "" : "s"}`,
+                            ...copy === void 0 ? {} : {
+                              human: () => buildViewHuman(effectiveCopy, selectedRows, effectiveCopyColumns),
+                              json: () => selectedRows.map((row) => effectiveCopy.agentRow ? effectiveCopy.agentRow(row) : row)
+                            },
+                            agent: () => copy === void 0 ? buildDefaultTableViewAgentInput(effectiveCopy, selectedRows, data, declaredVisibleCopyColumns, { scope: "selected" }) : buildViewAgentInput(effectiveCopy, selectedRows, data, { scope: "selected" }),
+                            aiVariants: copySubsetVariantFor(
+                              () => selectedRows,
+                              "selected"
+                            ),
+                            export: {
+                              items: [],
+                              sheetRows: () => selectedRows.map(
+                                (row) => projectDefaultTableCopyRow(row, declaredVisibleCopyColumns)
+                              ),
+                              sheetColumns: () => declaredVisibleCopyColumns.map((column) => ({
+                                id: columnId(column),
+                                label: column.label ?? (typeof column.header === "string" ? column.header : columnId(column))
+                              }))
+                            }
+                          }
+                        ) : null,
+                        selection.actions?.(selectedRows, selection.selectedIds)
+                      ] })
+                    ]
+                  }
+                ) : null
               ] }),
               /* @__PURE__ */ jsx42(
                 ColumnManager,
@@ -12807,7 +15413,7 @@ function HierarchyDragIndicatorLayer({
   scrollRef,
   resolve: resolve2
 }) {
-  const [indicator, setIndicator] = useState21(
+  const [indicator, setIndicator] = useState22(
     null
   );
   useDndMonitor2({
@@ -12948,6 +15554,71 @@ function normalizeColumnWidthsForColumns(widths, columns) {
     })
   );
 }
+function TableGroupHeaderRow({
+  group,
+  collapsed,
+  columns,
+  spacers,
+  leadingCols,
+  showActionsCol,
+  rowNoun,
+  onToggle
+}) {
+  const count = group.rows.length;
+  const summary = `${count.toLocaleString()} ${count === 1 ? rowNoun : `${rowNoun}s`}`;
+  const firstId = columns[0] ? columnId(columns[0]) : null;
+  return /* @__PURE__ */ jsxs32(
+    "tr",
+    {
+      "data-matrx-table-group-row": group.key,
+      "data-matrx-table-group-collapsed": collapsed ? "true" : "false",
+      className: "border-y border-border bg-muted/40",
+      children: [
+        Array.from({ length: leadingCols }).map((_, i) => /* @__PURE__ */ jsx42("td", { className: "px-2 py-1.5" }, `group-lead-${i}`)),
+        spacers && spacers.start > 0 ? /* @__PURE__ */ jsx42("td", { "aria-hidden": "true", className: "border-0 p-0", style: { width: `${spacers.start}px` } }) : null,
+        columns.map((col) => {
+          const id = columnId(col);
+          const aggregate = group.aggregates[id];
+          if (id === firstId) {
+            return /* @__PURE__ */ jsx42("td", { className: cn("px-2 py-1.5 align-middle", col.mobileHidden && "max-sm:hidden"), children: /* @__PURE__ */ jsxs32("div", { className: "flex items-center gap-1.5", children: [
+              /* @__PURE__ */ jsx42(
+                "button",
+                {
+                  type: "button",
+                  onClick: onToggle,
+                  "aria-expanded": !collapsed,
+                  "aria-label": `${collapsed ? "Show" : "Hide"} ${group.label}`,
+                  className: "inline-flex h-5 w-5 shrink-0 items-center justify-center rounded text-muted-foreground hover:bg-accent hover:text-foreground",
+                  children: collapsed ? /* @__PURE__ */ jsx42(ChevronRight, { className: "h-4 w-4" }) : /* @__PURE__ */ jsx42(ChevronDown, { className: "h-4 w-4" })
+                }
+              ),
+              /* @__PURE__ */ jsx42("span", { className: "truncate text-sm font-semibold text-foreground", children: group.label }),
+              /* @__PURE__ */ jsx42("span", { className: "whitespace-nowrap text-xs text-muted-foreground", children: summary })
+            ] }) }, id);
+          }
+          return /* @__PURE__ */ jsx42(
+            "td",
+            {
+              className: cn(
+                "px-2 py-1.5 align-middle text-xs font-medium text-muted-foreground",
+                // A subtotal lines up with the numbers it is a subtotal OF.
+                // Left-aligned under a right-aligned money column it reads as a
+                // different column's value.
+                alignForFormat(col) === "center" && "text-center",
+                alignForFormat(col) === "right" && "text-right",
+                col.mobileHidden && "max-sm:hidden"
+              ),
+              children: aggregate ? /* @__PURE__ */ jsx42("span", { "data-matrx-table-group-aggregate": id, className: "whitespace-nowrap", children: aggregate.label }) : null
+            },
+            id
+          );
+        }),
+        spacers && spacers.end > 0 ? /* @__PURE__ */ jsx42("td", { "aria-hidden": "true", className: "border-0 p-0", style: { width: `${spacers.end}px` } }) : null,
+        showActionsCol ? /* @__PURE__ */ jsx42("td", { className: "px-2 py-1.5" }) : null
+      ]
+    }
+  );
+}
 function columnWidthVar(width, resizedWidth, id, resizable) {
   if (width === void 0 && resizedWidth === void 0 && !resizable) return void 0;
   const inferredWidth = resizable && inferTableSearchRole(id) === "name" ? "12rem" : "auto";
@@ -12957,7 +15628,7 @@ function columnWidthVar(width, resizedWidth, id, resizable) {
   };
 }
 function DefaultJsonCell({ value }) {
-  const [open, setOpen] = useState21(false);
+  const [open, setOpen] = useState22(false);
   const host = useMatrxDataTableHost();
   const Viewer = host.JsonViewer;
   const text = JSON.stringify(value, null, 2);
@@ -13040,7 +15711,7 @@ function resolveStringTitle(title, fallback) {
 }
 
 // src/data-table/SavedViewsControl.tsx
-import { useId as useId3, useState as useState22 } from "react";
+import { useId as useId3, useState as useState23 } from "react";
 
 // src/dropdown-menu.tsx
 import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
@@ -13184,10 +15855,10 @@ function SavedViewsControl({
   onReload
 }) {
   const unsavedChangesId = useId3();
-  const [saveOpen, setSaveOpen] = useState22(false);
-  const [name, setName] = useState22("");
-  const [saving, setSaving] = useState22(false);
-  const [actionError, setActionError] = useState22(null);
+  const [saveOpen, setSaveOpen] = useState23(false);
+  const [name, setName] = useState23("");
+  const [saving, setSaving] = useState23(false);
+  const [actionError, setActionError] = useState23(null);
   const visibleError = actionError ?? error;
   const save = async () => {
     const next = name.trim();
@@ -13320,8 +15991,11 @@ export {
   CELL_TINT_CLASS,
   COLOR_RULE_OPS,
   COLOR_RULE_OP_LABELS,
+  DEFAULT_OVERSCAN,
+  DEFAULT_UNDO_DEPTH,
   DataRowInspector,
   DataRowWindow,
+  EMPTY_GROUP_KEY,
   EMPTY_TABLE_STYLE,
   FORMAT_MISMATCH_CLASS,
   FormattedCell,
@@ -13332,6 +16006,7 @@ export {
   MatrxUuidCell,
   NO_FROZEN_COLUMNS,
   OPS_WITH_VALUE,
+  PARTIAL_BADGE,
   ROW_TINT_CLASS,
   STYLE_COLORS,
   STYLE_COLOR_LABELS,
@@ -13341,22 +16016,62 @@ export {
   TABLE_STYLE_VERSION,
   TableTitleRow,
   TableViewTabs,
+  UNKNOWN_TOTAL_BADGE,
   alignForFormat,
+  allRange,
   applyStylePath,
+  boundsContain,
   buildRowAgentInput,
   buildViewAgentInput,
   buildViewHuman,
+  canRedo,
+  canUndo,
+  cellClipboardText,
+  cellDomKey,
+  cellsInRange,
+  classifyGridKey,
+  coerceGroupNumber,
   collectSelectOptions,
   colorForChoice,
+  columnRange,
+  computeVariableWindow,
+  computeWindow,
+  createUndoStack,
+  describeCoverage,
+  detectSeries,
+  directClickKinds,
   downloadTableAsXlsx,
   evaluateRule,
+  fillDown,
+  fillRange,
+  fillTargetFor,
   filterKindLabel,
+  flattenGroups,
   formatColumnValue,
+  formatGroupNumber,
+  gridToTsv,
+  groupKeyOf,
+  groupRows,
+  groupSummary,
   inferTableSearchRole,
+  isBlankGroupValue,
+  isDirectClickEditor,
+  isGroupCollapsed,
+  isSingleCell,
+  isSingleCellRange,
   isStyleColor,
+  moveSelection,
+  parseClipboardGrid,
   parseTableStyle,
   parseTableViewSnapshot,
   pixelWidth,
+  planPaste,
+  popRedo,
+  popUndo,
+  pushUndo,
+  rangeBounds,
+  rangeRows,
+  rangeSize,
   rankTableSearchRows,
   resolveCellColor,
   resolveColumnMarker,
@@ -13364,17 +16079,25 @@ export {
   resolveFrozenColumns,
   resolveRowColor,
   resolveTableSearchScopes,
+  rowRange,
   rowsToCsvFromColumns,
   rowsToMarkdownTable,
   rowsToRecordsFromColumns,
+  sameCell,
+  scrollOffsetForIndex,
   shortUuid,
+  storedValuesEqual,
   stylePath,
   tableStyleFromMetadata,
   tableStyleIsEmpty,
   tableUrlParamPrefix,
+  tileIndex,
+  toggleGroupCollapsed,
+  undoEntryFor,
   useMatrxDataTableHost,
   useMatrxTableRowAlchemy,
   useScrollPagination,
+  useSpreadsheetGrid,
   useTableUrlState
 };
 //# sourceMappingURL=index.js.map