@ai-matrx/design-system 0.22.0 → 0.25.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 useRef14,
+  useState as useState22
 } from "react";
 import {
   DndContext,
@@ -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;
@@ -6771,6 +6771,1611 @@ function projectColumnDragOrder(orderedIds, preview2) {
   return order;
 }
 
+// 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 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;
+  }
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return `d:${Number.isFinite(time) ? value.toISOString() : "invalid"}`;
+  }
+  return `o:${safeJson(value)}`;
+}
+function safeString(value) {
+  try {
+    return String(value);
+  } catch {
+    return "[unreadable]";
+  }
+}
+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, n) => acc + n, 0);
+      break;
+    case "average":
+      value = numbers.length === 0 ? null : numbers.reduce((acc, n) => acc + n, 0) / numbers.length;
+      break;
+    case "min":
+      value = numbers.length === 0 ? null : numbers.reduce((acc, n) => n < acc ? n : acc);
+      break;
+    case "max":
+      value = numbers.length === 0 ? null : numbers.reduce((acc, n) => n > acc ? n : 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;
+    }
+    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/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
+  );
+  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 useRef11, 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 = (n, max) => Math.min(Math.max(n, 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 n = text.length;
+  while (i < n) {
+    const ch = text[i];
+    if (cell === "" && ch === '"') {
+      let j = i + 1;
+      let out = "";
+      let closed = false;
+      while (j < n) {
+        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 >= n || text[j] === "	" || text[j] === "\n" || text[j] === "\r")) {
+        cell = out;
+        i = j;
+        if (i >= n) 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 = n > 0 && (text[n - 1] === "\n" || text[n - 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 n = b - a + 1;
+  if (n <= 0) return a;
+  if (i >= a && i <= b) return i;
+  if (i > b) return a + (i - a) % n;
+  return b - (a - 1 - i) % n;
+}
+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 = useRef11(null);
+  const optionsRef = useRef11(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 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 }
+    });
+    await applyPatches(result.patches, "fill-down", "Filled down");
+    announceSkips(result.skipped, result.summary);
+  }, [fillRequestBase, bounds, applyPatches, announceSkips]);
+  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 });
+      }
+    }
+    await applyPatches(patches, "clear", "Cleared");
+    announceSkips(skipped, `Cleared ${patches.length} cells.`);
+  }, [bounds, applyPatches, announceSkips]);
+  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;
+        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 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 });
+        }
+      }
+      void applyPatches(patches, "paste", "Pasted");
+      const tail = outside > 0 ? ` ${outside} landed past the edge of the table and were ignored.` : "";
+      announceSkips(skipped, `Pasted ${patches.length} cells.${tail}`);
+    },
+    [range, rowIds, columnIds, applyPatches, announceSkips]
+  );
+  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();
+          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 = useRef11(null);
+  fillTargetRef.current = fillTarget;
+  const boundsRef = useRef11(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
+      });
+      void applyPatches(result.patches, "fill", "Filled");
+      announceSkips(result.skipped, result.summary);
+    };
+    window.addEventListener("mouseup", commit);
+    return () => window.removeEventListener("mouseup", commit);
+  }, [options, fillRequestBase, applyPatches, announceSkips]);
+  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
+  };
+}
+
+// src/data-table/coverage.ts
+var PARTIAL_BADGE = "Partial";
+var UNKNOWN_TOTAL_BADGE = "Unknown total";
+var NUMBERS = new Intl.NumberFormat("en-US");
+function formatNumber(value) {
+  try {
+    return NUMBERS.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, "_");
@@ -6831,7 +8436,7 @@ function rankTableSearchRows(rows, columns, query, options = {}, extraText) {
 }
 
 // src/data-table/ColumnManager.tsx
-import { useEffect as useEffect11, useMemo as useMemo6, useState as useState16 } from "react";
+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({
@@ -6842,15 +8447,15 @@ function ColumnManager({
   hidden,
   onApply
 }) {
-  const byId = useMemo6(
+  const byId = useMemo7(
     () => new Map(columns.map((column) => [columnId(column), column])),
     [columns]
   );
-  const [draftOrder, setDraftOrder] = useState16(order);
-  const [draftHidden, setDraftHidden] = useState16(() => new Set(hidden));
-  const [draggedColumnId, setDraggedColumnId] = useState16(null);
-  const [dropTarget, setDropTarget] = useState16(null);
-  useEffect11(() => {
+  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));
@@ -7381,9 +8986,9 @@ function parseTableViewSnapshot(raw) {
 
 // src/data-table/MatrxUuidCell.tsx
 import {
-  useEffect as useEffect12,
-  useRef as useRef11,
-  useState as useState17
+  useEffect as useEffect13,
+  useRef as useRef12,
+  useState as useState18
 } from "react";
 import { jsx as jsx34, jsxs as jsxs24 } from "react/jsx-runtime";
 var SHORT_LEN = 8;
@@ -7424,11 +9029,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 = useRef12(null);
+  useEffect13(
     () => () => {
       if (timer.current) clearTimeout(timer.current);
     },
@@ -7723,7 +9328,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 +9349,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]);
@@ -8628,7 +10233,7 @@ 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 useRef13, useState as useState20 } from "react";
 import { jsx as jsx39, jsxs as jsxs29 } from "react/jsx-runtime";
 function CellEditShell({
   href,
@@ -8678,8 +10283,8 @@ function EditableTableCell({
   editTrigger = "click",
   editRequest
 }) {
-  const [open, setOpen] = useState19(false);
-  useEffect14(() => {
+  const [open, setOpen] = useState20(false);
+  useEffect15(() => {
     if (editRequest !== void 0) setOpen(true);
   }, [editRequest]);
   const usePencil = Boolean(href) || editTrigger === "pencil";
@@ -8772,10 +10377,10 @@ function InlineStringEditor({
   usePencil,
   editRequest
 }) {
-  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 handledEditRequest = useRef13(void 0);
+  useEffect15(() => {
     if (editRequest === void 0 || handledEditRequest.current === editRequest) return;
     handledEditRequest.current = editRequest;
     setDraft(value);
@@ -8931,8 +10536,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 +10634,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,
@@ -9159,7 +10764,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 +10781,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 +11326,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 +11417,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 +11478,16 @@ function MatrxDataTableCore({
   mobileCardsBreakpoint = "sm",
   getRowHref,
   onRowOpen,
-  density
+  density,
+  grouping,
+  virtualize,
+  coverage,
+  spreadsheet,
+  rowHeight: explicitRowHeight
 }) {
   const appendQuery = query?.mode === "controlled-append" ? query : null;
   const appendQueryKey = appendQuery?.pagination.queryKey ?? null;
-  const committedAppendQueryKey = useRef13(appendQueryKey);
+  const committedAppendQueryKey = useRef14(appendQueryKey);
   const appendSourceChanged = appendQuery !== null && committedAppendQueryKey.current !== appendQueryKey;
   const data = (appendQuery ? appendQuery.pagination.rows : suppliedData) ?? [];
   const isLoading = appendQuery ? appendQuery.pagination.loading : suppliedLoading;
@@ -9884,10 +11499,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 = useRef14({ 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 +11515,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 +11524,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 +11541,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 +11552,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 +11561,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 +11572,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 +11581,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 +11594,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 +11603,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 +11612,7 @@ function MatrxDataTableCore({
     }
     setInternalPage(next);
   };
-  const [internalPageSize, setInternalPageSize] = useState21(
+  const [internalPageSize, setInternalPageSize] = useState22(
     defaultPageSize
   );
   const pageSize = controlledQuery ? controlledQuery.state.pageSize : internalPageSize;
@@ -10008,28 +11623,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 = useRef14({});
+  const [savingByScope, setSavingByScope] = useState22({});
+  const savingScopesRef = useRef14(/* @__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 +11711,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 +11729,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 = useRef14(null);
+  const tableRef = useRef14(null);
+  const tableHeaderRef = useRef14(null);
+  const cardsScrollRef = useRef14(null);
+  const [documentStickyHeader, setDocumentStickyHeader] = useState22(false);
+  const documentStickyHeaderRef = useRef14(false);
+  const previousAppendKeyForScrollReset = useRef14(appendQueryKey);
   useLayoutEffect2(() => {
     const previous = previousAppendKeyForScrollReset.current;
     previousAppendKeyForScrollReset.current = appendQueryKey;
@@ -10146,13 +11761,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 = useRef14(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 +11781,7 @@ function MatrxDataTableCore({
       behavior: "smooth"
     });
   };
-  useEffect15(() => {
+  useEffect16(() => {
     updateScrollHint();
     window.addEventListener("resize", updateScrollHint);
     const el = scrollRef.current;
@@ -10240,30 +11855,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 = useRef14(new Set(columns.map(columnId)));
+  const draggedColumnId = useRef14(null);
+  const columnDragActive = useRef14(false);
+  const columnDragRaf = useRef14(null);
+  const columnDragScrollDirection = useRef14(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 +11905,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 = useRef14(null);
+  const measureVisibleColumnWidths = useCallback8(() => {
     const measured = {};
     const headers = tableRef.current ? Array.from(tableRef.current.querySelectorAll(
       "thead th[data-matrx-table-column-id]"
@@ -10322,7 +11937,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 +11972,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 +12000,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 +12024,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 +12065,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 +12107,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 +12115,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 +12150,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 +12158,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 +12228,8 @@ function MatrxDataTableCore({
     intelligentSearchEnabled,
     searchScope
   ]);
-  const lastNotifiedViewRows = useRef13(null);
-  useEffect15(() => {
+  const lastNotifiedViewRows = useRef14(null);
+  useEffect16(() => {
     if (!onViewChange) {
       lastNotifiedViewRows.current = null;
       return;
@@ -10623,7 +12238,7 @@ function MatrxDataTableCore({
     lastNotifiedViewRows.current = processed;
     if (changed) onViewChange(processed);
   }, [processed, onViewChange]);
-  useEffect15(() => {
+  useEffect16(() => {
     if (controlledQuery) return;
     setInternalPage(1);
   }, [
@@ -10667,7 +12282,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 +12290,268 @@ 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 = useRef14({
+    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 = useRef14(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))
+    } : null
+  );
+  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,7 +12586,7 @@ 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(() => {
+  const changeCount = useMemo8(() => {
     let n = 0;
     for (const fields of Object.values(edits)) {
       n += Object.keys(fields).length;
@@ -10874,7 +12742,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 +12774,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,7 +12957,7 @@ function MatrxDataTableCore({
     setEdits({});
     edit?.onCancel?.();
   };
-  useEffect15(() => {
+  useEffect16(() => {
     if (!host.rowContextRegistry || !contextMenu && !host.createDefaultRowContext) return;
     return host.rowContextRegistry.register(tableContextMenuInstanceId, (rowId) => {
       const row = data.find((candidate) => getRowId(candidate) === rowId);
@@ -11101,7 +12969,7 @@ function MatrxDataTableCore({
     });
   }, [buildRecordControls, contextMenu, data, getRowId, host.createDefaultRowContext, host.rowContextRegistry, tableContextMenuInstanceId]);
   const showActionsCol = windowEnabled || Boolean(rowActions) || showInlineRowCopy;
-  const selectedIdSet = useMemo7(
+  const selectedIdSet = useMemo8(
     () => new Set(selection?.selectedIds ?? []),
     [selection?.selectedIds]
   );
@@ -11113,11 +12981,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 = useRef14(null);
   const setSelectedIds = (next) => selection?.onSelectedIdsChange([...next]);
   const toggleRowSelected = (index, shiftKey) => {
     if (!selection) return;
@@ -11154,6 +13022,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,
@@ -11187,7 +13056,7 @@ function MatrxDataTableCore({
     }
     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 +13091,7 @@ function MatrxDataTableCore({
       sort
     ]
   );
-  const declaredDefaultViewSnapshot = useMemo7(
+  const declaredDefaultViewSnapshot = useMemo8(
     () => defaultViewSnapshot ?? {
       __kind: "matrx-table-view",
       version: 1,
@@ -11241,7 +13110,7 @@ function MatrxDataTableCore({
     },
     [columns, defaultPageSize, defaultSort, defaultViewSnapshot]
   );
-  const applySavedView = useCallback7(
+  const applySavedView = useCallback8(
     (rawSnapshot) => {
       const snapshot = parseTableViewSnapshot(rawSnapshot);
       if (!snapshot) {
@@ -11593,6 +13462,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 +13551,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 +13658,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 +13742,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 +13782,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;
@@ -11965,7 +13835,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: [
@@ -12029,6 +13899,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 +13924,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 +13946,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 +13969,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 +14016,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 +14089,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 +14144,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 +14264,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 +14290,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 +14315,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 +14337,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 +14345,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
                             ]
@@ -12525,7 +14529,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 +14877,7 @@ function HierarchyDragIndicatorLayer({
   scrollRef,
   resolve: resolve2
 }) {
-  const [indicator, setIndicator] = useState21(
+  const [indicator, setIndicator] = useState22(
     null
   );
   useDndMonitor2({
@@ -12948,6 +15018,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 +15092,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 +15175,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 +15319,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 +15455,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 +15470,7 @@ export {
   MatrxUuidCell,
   NO_FROZEN_COLUMNS,
   OPS_WITH_VALUE,
+  PARTIAL_BADGE,
   ROW_TINT_CLASS,
   STYLE_COLORS,
   STYLE_COLOR_LABELS,
@@ -13341,22 +15480,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 +15543,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