@lensui/lens-table 0.1.3 → 0.1.5

package/dist/index.js

@@ -27,6 +27,7 @@ var ZH_CN_GRID_LABELS = {
   sortDesc: "\u5F53\u524D\uFF1A\u964D\u5E8F",
   sortBoth: "\u5347\u5E8F / \u964D\u5E8F",
   dragColumn: "\u62D6\u52A8\u5217\u6392\u5E8F",
+  revealSelectedCell: "\u5B9A\u4F4D\u5230\u9009\u4E2D\u5355\u5143\u683C",
   previousYear: "\u4E0A\u4E00\u5E74",
   nextYear: "\u4E0B\u4E00\u5E74",
   previousMonth: "\u4E0A\u4E2A\u6708",
@@ -95,6 +96,7 @@ var EN_US_GRID_LABELS = {
   sortDesc: "Current: descending",
   sortBoth: "Ascending / descending",
   dragColumn: "Drag column to reorder",
+  revealSelectedCell: "Reveal selected cell",
   previousYear: "Previous year",
   nextYear: "Next year",
   previousMonth: "Previous month",
@@ -303,7 +305,6 @@ function LoadingSpinnerIcon() {
 // src/components/editors/ChoiceEditor.tsx
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 function ChoiceEditor({ value, options, style, labels, onChange, onCommit, onCancel }) {
-  const editorStyle = typeof style.width === "number" ? { ...style, width: Math.max(0, style.width - 1) } : style;
   const collection = createListCollection({
     items: options,
     itemToValue: (item) => item.value,
@@ -313,7 +314,7 @@ function ChoiceEditor({ value, options, style, labels, onChange, onCommit, onCan
     Select.Root,
     {
       className: "rvg-choice-editor",
-      style: editorStyle,
+      style,
       collection,
       value: value ? [value] : [],
       defaultOpen: true,
@@ -863,6 +864,8 @@ function ellipsizeText(context, text, maxWidth) {
 }
 function paintGrid(options) {
   const { context: ctx, width, height, pixelRatio, scrollLeft, scrollTop, rowHeight, headerHeight, fixedHeader, verticalBorderless, striped, columnDraggable, sortState, filterValues, hoveredHeaderAction, rows, columns, metrics, range, selection, editing, hoveredRowIndex, selectionRange, selectedRowKeys, selectedColumnKeys, highlightEditedCells, highlightInsertedRows, insertedRowKeys, editedCellKeys, cellAnnotations, getRowKey, rowDragPreview } = options;
+  const headerLeafTop = options.headerLeafTop ?? 0;
+  const headerLeafHeight = options.headerLeafHeight ?? headerHeight;
   const colors = { ...COLORS, ...options.colors };
   const bodyTop = options.bodyTop ?? headerHeight;
   const getCellSpan = (rowIndex, columnIndex) => options.cellSpans.get(getCellCoordKey(rowIndex, columnIndex));
@@ -879,9 +882,17 @@ function paintGrid(options) {
   ctx.fillRect(0, 0, width, height);
   ctx.font = "13px Inter, ui-sans-serif, system-ui, sans-serif";
   ctx.textBaseline = "middle";
-  const leftFixedWidth = columns.reduce((value, column, index) => column.fixed === "left" ? Math.max(value, metrics[index].right) : value, 0);
+  const leftFixedWidth = columns.reduce((value, column, index) => column.fixed === "left" ? value + metrics[index].width : value, 0);
   const rightFixedWidth = columns.reduce((value, column, index) => column.fixed === "right" ? value + metrics[index].width : value, 0);
   const rightFixedLeft = width - rightFixedWidth;
+  const rightFixedBoundaryInset = rightFixedWidth > 0 && !verticalBorderless ? 1 : 0;
+  const leftOffsets = /* @__PURE__ */ new Map();
+  let leftOffset = 0;
+  for (let index = 0; index < columns.length; index += 1) {
+    if (columns[index].fixed !== "left") continue;
+    leftOffsets.set(index, leftOffset);
+    leftOffset += metrics[index].width;
+  }
   const rightOffsets = /* @__PURE__ */ new Map();
   let rightOffset = 0;
   for (let index = columns.length - 1; index >= 0; index -= 1) {
@@ -889,8 +900,14 @@ function paintGrid(options) {
     rightOffsets.set(index, rightOffset);
     rightOffset += metrics[index].width;
   }
+  const scrollableLefts = /* @__PURE__ */ new Map();
+  let scrollableLeft = leftFixedWidth;
+  for (let index = 0; index < columns.length; index += 1) {
+    scrollableLefts.set(index, scrollableLeft);
+    if (columns[index].fixed === void 0) scrollableLeft += metrics[index].width;
+  }
   const getColumnX = (index) => {
-    return columns[index].fixed === "left" ? metrics[index].left : columns[index].fixed === "right" ? width - (rightOffsets.get(index) ?? 0) - metrics[index].width : metrics[index].left - scrollLeft;
+    return columns[index].fixed === "left" ? leftOffsets.get(index) ?? 0 : columns[index].fixed === "right" ? width - (rightOffsets.get(index) ?? 0) - metrics[index].width : (scrollableLefts.get(index) ?? leftFixedWidth) - scrollLeft;
   };
   const paintBodyColumns = (layer) => {
     const rowStart = Math.max(0, range.rowStart - Math.max(0, options.maxRowSpan - 1));
@@ -1040,7 +1057,7 @@ function paintGrid(options) {
       if (!verticalBorderless) ctx.fillRect(x + metric.width - 1, headerY, 1, headerHeight);
       ctx.fillRect(x, headerY + headerHeight - 1, metric.width, 1);
       const column = columns[columnIndex];
-      if (!column.rowSelection && !column.rowDragHandle && !column.rowNumber && !column.renderHeader && column.title) {
+      if (headerLeafTop === 0 && !column.rowSelection && !column.rowDragHandle && !column.rowNumber && !column.renderHeader && column.title) {
         ctx.font = "600 13px Inter, ui-sans-serif, system-ui, sans-serif";
         const titleWidth = ctx.measureText(column.title).width;
         const visibleActions = getVisibleHeaderActions(column, metric.width, columnDraggable, titleWidth);
@@ -1057,11 +1074,11 @@ function paintGrid(options) {
         const textX = titleAlign === "right" ? x + contentWidth - padding : titleAlign === "center" ? x + centeredTextX : x + padding;
         ctx.save();
         ctx.beginPath();
-        ctx.rect(x + 2, headerY + 1, Math.max(0, clipWidth - 4), headerHeight - 2);
+        ctx.rect(x + 2, headerY + headerLeafTop + 1, Math.max(0, clipWidth - 4), headerLeafHeight - 2);
         ctx.clip();
         ctx.fillStyle = colors.muted;
         ctx.textAlign = titleAlign === "right" ? "right" : titleAlign === "center" ? "center" : "left";
-        ctx.fillText(title, textX, headerY + headerHeight / 2);
+        ctx.fillText(title, textX, headerY + headerLeafTop + headerLeafHeight / 2);
         ctx.restore();
       }
     }
@@ -1069,22 +1086,6 @@ function paintGrid(options) {
   paintHeaderColumns("scroll");
   paintHeaderColumns("left");
   paintHeaderColumns("right");
-  if (leftFixedWidth > 0 && scrollLeft > 0) {
-    const shadowWidth = 10;
-    const shadow = ctx.createLinearGradient(leftFixedWidth, 0, leftFixedWidth + shadowWidth, 0);
-    shadow.addColorStop(0, "rgba(5, 5, 5, 0.06)");
-    shadow.addColorStop(1, "rgba(5, 5, 5, 0)");
-    ctx.fillStyle = shadow;
-    ctx.fillRect(leftFixedWidth, 0, shadowWidth, height);
-  }
-  if (rightFixedWidth > 0 && scrollLeft < (metrics[metrics.length - 1]?.right ?? 0) - width) {
-    const shadowWidth = 10;
-    const shadow = ctx.createLinearGradient(rightFixedLeft - shadowWidth, 0, rightFixedLeft, 0);
-    shadow.addColorStop(0, "rgba(5, 5, 5, 0)");
-    shadow.addColorStop(1, "rgba(5, 5, 5, 0.06)");
-    ctx.fillStyle = shadow;
-    ctx.fillRect(rightFixedLeft - shadowWidth, 0, shadowWidth, height);
-  }
   if (rightFixedWidth > 0 && !verticalBorderless) {
     ctx.fillStyle = colors.grid;
     ctx.fillRect(rightFixedLeft - 1, 0, 1, height);
@@ -1108,22 +1109,22 @@ function paintGrid(options) {
     const markerBottom = Math.min(bottom, height);
     const startX = getColumnX(columnStart);
     const endX = getColumnX(columnEnd) + metrics[columnEnd].width;
-    const visibleLeft = columns[columnStart].fixed === "left" ? Math.max(0, startX) : Math.max(leftFixedWidth - 1, startX);
+    const visibleLeft = columns[columnStart].fixed === "left" ? Math.max(0, startX) : Math.max(leftFixedWidth, startX);
     const visibleRight = columns[columnEnd].fixed === "right" ? Math.min(width, endX) : Math.min(rightFixedLeft, endX);
     ctx.fillStyle = colors.selection;
     if (markerBottom > markerTop) {
       if (columns[columnStart].fixed === void 0 && startX < leftFixedWidth) {
-        ctx.fillRect(Math.max(0, leftFixedWidth - 1), markerTop, 2, markerBottom - markerTop);
+        ctx.fillRect(Math.max(0, leftFixedWidth), markerTop, 2, markerBottom - markerTop);
       }
       if (columns[columnEnd].fixed === void 0 && endX > rightFixedLeft) {
-        ctx.fillRect(Math.max(0, rightFixedLeft - 1), markerTop, 2, markerBottom - markerTop);
+        ctx.fillRect(Math.max(0, rightFixedLeft - 2 - rightFixedBoundaryInset), markerTop, 2, markerBottom - markerTop);
       }
     }
     if (visibleRight > visibleLeft) {
       if (top < clipTop) ctx.fillRect(visibleLeft, clipTop, visibleRight - visibleLeft, 2);
       if (bottom > height) ctx.fillRect(visibleLeft, height - 2, visibleRight - visibleLeft, 2);
     } else if (top < clipTop || bottom > height) {
-      const markerX = endX <= leftFixedWidth ? Math.max(0, leftFixedWidth - 1) : Math.max(0, rightFixedLeft - 1);
+      const markerX = endX <= leftFixedWidth ? Math.max(0, leftFixedWidth) : Math.max(0, rightFixedLeft - 2 - rightFixedBoundaryInset);
       ctx.fillRect(markerX, top < clipTop ? clipTop : height - 2, 2, 2);
     }
   }
@@ -1145,15 +1146,15 @@ function paintGrid(options) {
       const visibleRight = x + selectionWidth;
       const visibleBottom = y + selectionHeight;
       const selectionTop = fixedHeader ? bodyTop : 0;
-      const selectionClipTop = fixedHeader ? Math.max(0, selectionTop - 1) : selectionTop;
+      const selectionClipTop = selectionTop;
       const hiddenAboveHeader = visibleBottom <= selectionTop;
       const hiddenBelowViewport = y >= height;
       const hiddenBehindLeft = !isFixed && visibleRight <= visibleLeft;
       const hiddenBehindRight = !isFixed && x >= selectionAreaRight;
-      const leftMarkerX = Math.max(0, leftFixedWidth - 1);
+      const leftMarkerX = Math.max(0, leftFixedWidth);
       if ((hiddenAboveHeader || hiddenBelowViewport) && (hiddenBehindLeft || hiddenBehindRight)) {
         const markerSize = 2;
-        const markerX = hiddenBehindLeft ? leftMarkerX : selectionAreaRight - borderWidth;
+        const markerX = hiddenBehindLeft ? leftMarkerX : selectionAreaRight - borderWidth - rightFixedBoundaryInset;
         const markerY = hiddenAboveHeader ? selectionClipTop : height - markerSize;
         ctx.fillStyle = colors.selection;
         ctx.fillRect(markerX, markerY, markerSize, markerSize);
@@ -1161,7 +1162,7 @@ function paintGrid(options) {
       }
       ctx.save();
       ctx.beginPath();
-      const clipLeft = fixedSide === "left" ? 0 : Math.max(0, leftFixedWidth - 1);
+      const clipLeft = fixedSide === "left" ? 0 : Math.max(0, leftFixedWidth);
       const clipRight = Math.min(width, selectionAreaRight + 1);
       ctx.rect(clipLeft, selectionClipTop, clipRight - clipLeft, height - selectionClipTop);
       ctx.clip();
@@ -1179,14 +1180,14 @@ function paintGrid(options) {
       if (hiddenBehindLeft || hiddenBehindRight) {
         const markerTop = Math.max(y - borderWidth, selectionTop);
         const markerBottom = Math.min(y + selectionHeight + 1, height);
-        const markerX = hiddenBehindLeft ? leftMarkerX : selectionAreaRight - borderWidth;
+        const markerX = hiddenBehindLeft ? leftMarkerX : selectionAreaRight - borderWidth - rightFixedBoundaryInset;
         ctx.fillRect(markerX, markerTop, borderWidth, Math.max(0, markerBottom - markerTop));
       }
       if (hiddenAboveHeader || hiddenBelowViewport || hiddenBehindLeft || hiddenBehindRight) {
         ctx.restore();
         return;
       }
-      const borderLeft = x <= 0 ? 0 : Math.max(x - borderWidth, visibleLeft - 1);
+      const borderLeft = x <= 0 ? 0 : Math.max(x - borderWidth, visibleLeft);
       const borderRight = Math.min(x + selectionWidth - 1, selectionAreaRight - borderWidth, width - borderWidth);
       const borderTop = Math.max(y - borderWidth, selectionClipTop);
       const borderBottom = Math.min(y + selectionHeight - 1, height - borderWidth);
@@ -1236,6 +1237,45 @@ var getRowNumberColumnWidth = (rowCount) => {
   const digits = String(Math.max(1, rowCount)).length;
   return digits <= 4 ? 44 : 44 + (digits - 4) * 8;
 };
+function getColumnDepth(column) {
+  if (!column.children?.length) return 1;
+  return 1 + Math.max(...column.children.map(getColumnDepth));
+}
+function flattenDataColumns(columns, inheritedFixed, insideGroup = false) {
+  return columns.flatMap((column) => {
+    if (!column.children?.length) {
+      return insideGroup ? [{ ...column, fixed: inheritedFixed }] : [column];
+    }
+    return flattenDataColumns(column.children, column.fixed ?? inheritedFixed, true);
+  });
+}
+function buildHeaderCells(sourceColumns, utilityColumnCount, depth) {
+  const cells = [];
+  let leafIndex = utilityColumnCount;
+  const walk = (column, level, inheritedFixed, insideGroup, rootIndex, parentKey) => {
+    const fixedColumn = insideGroup ? { ...column, fixed: inheritedFixed } : column;
+    if (!fixedColumn.children?.length) {
+      const startIndex2 = leafIndex;
+      leafIndex += 1;
+      cells.push({ key: fixedColumn.key, column: fixedColumn, level: depth - 1, startIndex: startIndex2, endIndex: startIndex2, leaf: true, parentKey, rootIndex });
+      return { startIndex: startIndex2, endIndex: startIndex2 };
+    }
+    const startIndex = leafIndex;
+    fixedColumn.children.forEach((child) => walk(child, level + 1, fixedColumn.fixed, true, rootIndex, fixedColumn.key));
+    const endIndex = leafIndex - 1;
+    cells.push({ key: fixedColumn.key, column: fixedColumn, level, startIndex, endIndex, leaf: false, parentKey, rootIndex });
+    return { startIndex, endIndex };
+  };
+  sourceColumns.forEach((column, index) => walk(column, 0, void 0, false, index));
+  return cells;
+}
+function hasNestedFixedColumns(columns, insideGroup = false) {
+  return columns.some((column) => insideGroup && column.fixed !== void 0 || (column.children?.length ? hasNestedFixedColumns(column.children, true) : false));
+}
+function isProductionRuntime() {
+  const env = globalThis.process?.env?.NODE_ENV;
+  return env === "production";
+}
 var createPendingInsertId = () => `table-inserted-${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`}`;
 var waitForPaint = () => new Promise((resolve) => {
   requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
@@ -1256,6 +1296,25 @@ var createEmptyCellSpanLookup = () => ({
   covered: /* @__PURE__ */ new Map(),
   maxRowSpan: 1
 });
+var summaryFunctionIds = /* @__PURE__ */ new WeakMap();
+var nextSummaryFunctionId = 1;
+function getSummaryFunctionId(fn) {
+  if (!fn) return "";
+  const existing = summaryFunctionIds.get(fn);
+  if (existing !== void 0) return existing;
+  const next = nextSummaryFunctionId;
+  nextSummaryFunctionId += 1;
+  summaryFunctionIds.set(fn, next);
+  return next;
+}
+function getSummarySignature(columns) {
+  return columns.filter((column) => Boolean(column.summary)).map((column) => [
+    column.key,
+    String(column.dataIndex ?? ""),
+    typeof column.summary === "function" ? getSummaryFunctionId(column.summary) : "sum",
+    getSummaryFunctionId(column.formatter)
+  ].join("
")).join("");
+}
 async function calculateSummaryValues(columns, rows) {
   const values = /* @__PURE__ */ new Map();
   for (const column of columns) {
@@ -1350,10 +1409,24 @@ function Table({
 }) {
   const rowHeight = layout?.rowHeight ?? rowHeightProp ?? 36;
   const baseHeaderHeight = layout?.headerHeight ?? headerHeightProp ?? 40;
+  const headerDepth = useMemo(() => Math.max(1, ...sourceColumns.map(getColumnDepth)), [sourceColumns]);
   const { language, labels } = useMemo(() => resolveGridLocale(locale), [locale]);
   const customHeaderContentRefs = useRef2(/* @__PURE__ */ new Map());
-  const [measuredHeaderHeight, setMeasuredHeaderHeight] = useState4(0);
-  const headerHeight = Math.max(baseHeaderHeight, measuredHeaderHeight);
+  const customHeaderMeasurementsRef = useRef2(/* @__PURE__ */ new Map());
+  const [measuredHeaderRowHeights, setMeasuredHeaderRowHeights] = useState4([]);
+  const headerRowHeights = useMemo(() => Array.from({ length: headerDepth }, (_, level) => Math.max(baseHeaderHeight, measuredHeaderRowHeights[level] ?? 0)), [baseHeaderHeight, headerDepth, measuredHeaderRowHeights]);
+  const headerRowOffsets = useMemo(() => {
+    const offsets = [];
+    let top = 0;
+    headerRowHeights.forEach((height2) => {
+      offsets.push(top);
+      top += height2;
+    });
+    return offsets;
+  }, [headerRowHeights]);
+  const headerHeight = headerRowHeights.reduce((total, height2) => total + height2, 0);
+  const headerLeafTop = headerRowOffsets[headerDepth - 1] ?? 0;
+  const headerLeafHeight = headerRowHeights[headerDepth - 1] ?? baseHeaderHeight;
   const hasVerticalBorders = !(borderless ?? verticalBorderless ?? false);
   const hasStripedRows = Boolean(striped);
   const stripedColor = typeof striped === "string" ? striped : void 0;
@@ -1373,6 +1446,13 @@ function Table({
   const summaryEmptyValue = typeof summary === "object" ? summary.emptyValue ?? "" : "";
   const contextMenuEnabled = contextMenuConfig !== false;
   const customContextMenuConfig = typeof contextMenuConfig === "object" ? contextMenuConfig : void 0;
+  const [resizedColumnWidths, setResizedColumnWidths] = useState4({});
+  const leafSourceColumns = useMemo(() => flattenDataColumns(sourceColumns), [sourceColumns]);
+  useEffect2(() => {
+    if (!isProductionRuntime() && hasNestedFixedColumns(sourceColumns)) {
+      console.warn("[Table] Multi-level headers only support fixed columns on top-level columns. Nested fixed values are ignored.");
+    }
+  }, [sourceColumns]);
   const columns = useMemo(() => {
     const utilityColumns = [];
     if (rowDraggable) {
@@ -1384,9 +1464,24 @@ function Table({
     if (rowNumber) {
       utilityColumns.push({ key: "__rvg_row_number__", title: "#", width: getRowNumberColumnWidth(sourceRows.length), align: "center", fixed: "left", rowNumber: true });
     }
-    return [...utilityColumns, ...sourceColumns];
-  }, [rowDraggable, rowNumber, rowSelection, sourceColumns, sourceRows.length]);
+    const dataColumns = leafSourceColumns.map((column) => {
+      const resizedWidth = resizedColumnWidths[column.key];
+      return resizedWidth === void 0 ? column : { ...column, width: resizedWidth };
+    });
+    return [...utilityColumns, ...dataColumns];
+  }, [leafSourceColumns, resizedColumnWidths, rowDraggable, rowNumber, rowSelection, sourceRows.length]);
   const utilityColumnCount = (rowDraggable ? 1 : 0) + (rowSelection ? 1 : 0) + (rowNumber ? 1 : 0);
+  const headerCells = useMemo(() => buildHeaderCells(sourceColumns, utilityColumnCount, headerDepth), [headerDepth, sourceColumns, utilityColumnCount]);
+  const activeCustomHeaderLevels = useMemo(() => {
+    const levels = /* @__PURE__ */ new Map();
+    columns.forEach((column) => {
+      if (column.renderHeader) levels.set(column.key, headerDepth - 1);
+    });
+    headerCells.forEach((cell) => {
+      if (cell.column.renderHeader) levels.set(`group:${cell.key}:${cell.level}`, cell.level);
+    });
+    return levels;
+  }, [columns, headerCells, headerDepth]);
   const canvasRef = useRef2(null);
   const scrollerRef = useRef2(null);
   const frameRef = useRef2(null);
@@ -1404,6 +1499,15 @@ function Table({
   const dragGuideRef = useRef2(null);
   const rowDragGuideRef = useRef2(null);
   const selectionFocusRef = useRef2(null);
+  const selectionEdgeTargetRef = useRef2(null);
+  const verticalScrollbarRef = useRef2(null);
+  const verticalScrollbarThumbRef = useRef2(null);
+  const verticalScrollbarDragRef = useRef2(null);
+  const horizontalScrollbarRef = useRef2(null);
+  const horizontalScrollbarThumbRef = useRef2(null);
+  const horizontalScrollbarDragRef = useRef2(null);
+  const verticalScrollbarVisibilityTimerRef = useRef2(null);
+  const horizontalScrollbarVisibilityTimerRef = useRef2(null);
   const rowByKeyRef = useRef2(/* @__PURE__ */ new Map());
   const rowIndexByKeyRef = useRef2(/* @__PURE__ */ new Map());
   const headerIconsRef = useRef2(null);
@@ -1456,24 +1560,57 @@ function Table({
     rangeDragRef.current = null;
     setSelectionRange(null);
   }, [rangeSelection]);
+  useEffect2(() => {
+    setResizedColumnWidths((current) => {
+      const sourceColumnByKey = new Map(leafSourceColumns.map((column) => [column.key, column]));
+      let changed = false;
+      const next = {};
+      Object.entries(current).forEach(([key, value]) => {
+        const sourceColumn = sourceColumnByKey.get(key);
+        if (!sourceColumn) {
+          changed = true;
+          return;
+        }
+        if (sourceColumn.width !== void 0 && sourceColumn.width !== value) {
+          changed = true;
+          return;
+        }
+        next[key] = value;
+      });
+      return changed ? next : current;
+    });
+  }, [leafSourceColumns]);
   useEffect2(() => () => {
     if (headerTooltipTimerRef.current !== null) clearTimeout(headerTooltipTimerRef.current);
     if (cellTooltipTimerRef.current !== null) clearTimeout(cellTooltipTimerRef.current);
   }, []);
   const measureCustomHeaderHeight = useCallback2(() => {
-    let nextHeight = 0;
+    const nextHeights = Array.from({ length: headerDepth }, () => baseHeaderHeight);
     customHeaderContentRefs.current.forEach((node) => {
-      nextHeight = Math.max(nextHeight, Math.ceil(node.scrollHeight) + 16);
+      const headerCell = node.closest(".rvg-header-title");
+      const key = headerCell?.dataset.measureKey;
+      const level = key ? activeCustomHeaderLevels.get(key) : void 0;
+      if (!key || level === void 0 || level < 0 || level >= nextHeights.length) return;
+      customHeaderMeasurementsRef.current.set(key, { level, height: Math.ceil(node.scrollHeight) + 16 });
     });
-    setMeasuredHeaderHeight((current) => current === nextHeight ? current : nextHeight);
-  }, []);
+    customHeaderMeasurementsRef.current.forEach((measurement, key) => {
+      if (!activeCustomHeaderLevels.has(key)) return;
+      nextHeights[measurement.level] = Math.max(nextHeights[measurement.level], measurement.height);
+    });
+    setMeasuredHeaderRowHeights((current) => {
+      const changed = nextHeights.length !== current.length || nextHeights.some((height2, index) => height2 !== current[index]);
+      return changed ? nextHeights : current;
+    });
+  }, [activeCustomHeaderLevels, baseHeaderHeight, headerDepth]);
   useLayoutEffect2(() => {
-    const activeCustomHeaderKeys = new Set(columns.filter((column) => column.renderHeader).map((column) => column.key));
     customHeaderContentRefs.current.forEach((_, key) => {
-      if (!activeCustomHeaderKeys.has(key)) customHeaderContentRefs.current.delete(key);
+      if (!activeCustomHeaderLevels.has(key)) customHeaderContentRefs.current.delete(key);
+    });
+    customHeaderMeasurementsRef.current.forEach((_, key) => {
+      if (!activeCustomHeaderLevels.has(key)) customHeaderMeasurementsRef.current.delete(key);
     });
-    if (customHeaderContentRefs.current.size === 0) {
-      setMeasuredHeaderHeight(0);
+    if (activeCustomHeaderLevels.size === 0) {
+      setMeasuredHeaderRowHeights([]);
       return;
     }
     measureCustomHeaderHeight();
@@ -1481,7 +1618,7 @@ function Table({
     const observer = new ResizeObserver(measureCustomHeaderHeight);
     customHeaderContentRefs.current.forEach((node) => observer.observe(node));
     return () => observer.disconnect();
-  }, [columns, measureCustomHeaderHeight, viewport.width]);
+  }, [activeCustomHeaderLevels, measureCustomHeaderHeight, viewport.width]);
   const [filterEditor, setFilterEditor] = useState4(null);
   const [contextMenu, setContextMenu] = useState4(null);
   const [insertCounts, setInsertCounts] = useState4({ before: 1, after: 1 });
@@ -1491,6 +1628,7 @@ function Table({
   const [deleteBusy, setDeleteBusy] = useState4(false);
   const [toast, setToast] = useState4(null);
   const [resizeGuideX, setResizeGuideX] = useState4(null);
+  const [resizeGuideTop, setResizeGuideTop] = useState4(0);
   const [hoveredHeaderAction, setHoveredHeaderAction] = useState4(null);
   const [visibleHeaderTooltip, setVisibleHeaderTooltip] = useState4(null);
   const [hoveredCellTooltip, setHoveredCellTooltip] = useState4(null);
@@ -1575,7 +1713,17 @@ function Table({
   const metrics = useMemo(() => buildColumnMetrics(columns, { columnDraggable, viewportWidth: viewport.width }), [columnDraggable, columns, viewport.width]);
   const contentWidth = metrics.length > 0 ? metrics[metrics.length - 1].right : 0;
   const contentHeight = rows.length * rowHeight;
-  const fixedWidth = useMemo(() => columns.reduce((width2, column, index) => column.fixed === "left" ? Math.max(width2, metrics[index].right) : width2, 0), [columns, metrics]);
+  const fixedWidth = useMemo(() => columns.reduce((width2, column, index) => column.fixed === "left" ? width2 + metrics[index].width : width2, 0), [columns, metrics]);
+  const leftFixedOffsets = useMemo(() => {
+    const offsets = /* @__PURE__ */ new Map();
+    let offset = 0;
+    for (let index = 0; index < columns.length; index += 1) {
+      if (columns[index].fixed !== "left") continue;
+      offsets.set(index, offset);
+      offset += metrics[index].width;
+    }
+    return offsets;
+  }, [columns, metrics]);
   const rightFixedWidth = useMemo(() => columns.reduce((width2, column, index) => column.fixed === "right" ? width2 + metrics[index].width : width2, 0), [columns, metrics]);
   const rightFixedOffsets = useMemo(() => {
     const offsets = /* @__PURE__ */ new Map();
@@ -1587,9 +1735,20 @@ function Table({
     }
     return offsets;
   }, [columns, metrics]);
+  const scrollableColumnLefts = useMemo(() => {
+    const lefts = [];
+    let width2 = fixedWidth;
+    for (let index = 0; index < columns.length; index += 1) {
+      lefts[index] = width2;
+      if (columns[index].fixed === void 0) width2 += metrics[index].width;
+    }
+    return lefts;
+  }, [columns, fixedWidth, metrics]);
+  const getScrollableColumnLeft = useCallback2((columnIndex) => scrollableColumnLefts[columnIndex] ?? fixedWidth, [fixedWidth, scrollableColumnLefts]);
   const hasRowSelectionColumn = useMemo(() => columns.some((column) => column.rowSelection), [columns]);
   const rowSelectionMode = typeof rowSelection === "object" ? rowSelection.mode ?? "multiple" : "multiple";
-  const hasSummaryRow = useMemo(() => rows.length > 0 && summaryEnabled && columns.some((column) => Boolean(column.summary)), [columns, rows.length, summaryEnabled]);
+  const summarySignature = useMemo(() => getSummarySignature(columns), [columns]);
+  const hasSummaryRow = rows.length > 0 && summaryEnabled && summarySignature.length > 0;
   const topSummaryHeight = hasSummaryRow && summaryPosition === "top" ? rowHeight : 0;
   const bottomSummaryHeight = hasSummaryRow && summaryPosition === "bottom" ? rowHeight : 0;
   const bodyTop = headerHeight + topSummaryHeight;
@@ -1597,22 +1756,22 @@ function Table({
   const realContentHeight = bodyTop + bodyContentHeight + bottomSummaryHeight + (contentWidth > viewport.width ? horizontalScrollbarHeight : 0);
   const effectiveHeight = autoHeight ? Math.max(bodyTop + bottomSummaryHeight, Math.min(resolvedHeight, realContentHeight)) : resolvedHeight;
   const renderHeight = Math.max(0, effectiveHeight - bottomSummaryHeight);
-  const bodyViewportHeight = Math.max(0, renderHeight - (fixedHeader ? headerHeight : 0) - topSummaryHeight);
-  const [summaryState, setSummaryState] = useState4(() => ({ columns: null, rows: null, values: /* @__PURE__ */ new Map(), pending: false }));
-  const summaryPending = hasSummaryRow && (loading || summaryState.pending || summaryState.columns !== columns || summaryState.rows !== rows);
-  const summaryValues = hasSummaryRow && summaryState.columns === columns && summaryState.rows === rows ? summaryState.values : /* @__PURE__ */ new Map();
+  const bodyViewportHeight = Math.max(0, renderHeight - (fixedHeader ? headerHeight + topSummaryHeight : 0));
+  const [summaryState, setSummaryState] = useState4(() => ({ signature: "", rows: null, values: /* @__PURE__ */ new Map(), pending: false }));
+  const summaryPending = hasSummaryRow && (loading || summaryState.pending || summaryState.signature !== summarySignature || summaryState.rows !== rows);
+  const summaryValues = hasSummaryRow && summaryState.signature === summarySignature && summaryState.rows === rows ? summaryState.values : /* @__PURE__ */ new Map();
   useEffect2(() => {
     let cancelled = false;
     if (!hasSummaryRow) {
-      setSummaryState((current) => current.columns === null && current.rows === null && current.values.size === 0 && !current.pending ? current : { columns: null, rows: null, values: /* @__PURE__ */ new Map(), pending: false });
+      setSummaryState((current) => current.signature === "" && current.rows === null && current.values.size === 0 && !current.pending ? current : { signature: "", rows: null, values: /* @__PURE__ */ new Map(), pending: false });
       return () => {
         cancelled = true;
       };
     }
     setSummaryState((current) => ({
-      columns,
+      signature: summarySignature,
       rows,
-      values: current.columns === columns && current.rows === rows ? current.values : /* @__PURE__ */ new Map(),
+      values: current.signature === summarySignature && current.rows === rows ? current.values : /* @__PURE__ */ new Map(),
       pending: true
     }));
     if (loading) {
@@ -1625,13 +1784,13 @@ function Table({
       if (cancelled) return;
       const values = await calculateSummaryValues(columns, rows);
       if (cancelled) return;
-      setSummaryState({ columns, rows, values, pending: false });
+      setSummaryState({ signature: summarySignature, rows, values, pending: false });
     };
     void run();
     return () => {
       cancelled = true;
     };
-  }, [columns, hasSummaryRow, loading, rows]);
+  }, [hasSummaryRow, loading, rows, summarySignature]);
   const domRange = useMemo(() => {
     if (!isVirtualized) return { rowStart: 0, rowEnd: rows.length, columnStart: 0, columnEnd: columns.length };
     const currentScroll2 = scrollRef.current;
@@ -1773,11 +1932,163 @@ function Table({
     const scroll = scrollRef.current;
     const rowScrollTop = fixedHeader ? scroll.top : Math.max(0, scroll.top - bodyTop);
     const range = isVirtualized ? getViewportRange(scroll.left, rowScrollTop, viewport.width, bodyViewportHeight, rows.length, rowHeight, metrics, virtualOverscan) : { rowStart: 0, rowEnd: rows.length, columnStart: 0, columnEnd: columns.length };
-    paintGrid({ context, width: viewport.width, height: renderHeight, pixelRatio: ratio, scrollLeft: scroll.left, scrollTop: scroll.top, rowHeight, headerHeight, bodyTop, suppressLastRowBottomBorder: bottomSummaryHeight > 0, suppressFrameBottomBorder: bottomSummaryHeight > 0, fixedHeader, verticalBorderless: !hasVerticalBorders, striped: hasStripedRows, columnDraggable, sortState, filterValues, hoveredHeaderAction: hoveredHeaderActionRef.current, rows, columns, metrics, range, selection, editing, hoveredRowIndex: hoveredRowIndexRef.current, selectionRange, selectedRowKeys: selectedRowKeySet, selectedColumnKeys: selectedColumnKeySet, cellSpans: cellSpanLookup.covered, maxRowSpan: cellSpanLookup.maxRowSpan, highlightEditedCells: highlightsEditedCells, highlightInsertedRows: highlightsInsertedRows, insertedRowKeys: insertedRowKeySet, editedCellKeys, cellAnnotations, getRowKey, rowDragPreview, colors: themeColors });
-  }, [bodyTop, bodyViewportHeight, bottomSummaryHeight, cellAnnotations, cellSpanLookup, columnDraggable, columns, editedCellHighlightColor, editedCellKeys, editing, renderHeight, filterValues, fixedHeader, getRowKey, hasStripedRows, hasVerticalBorders, headerHeight, highlightsEditedCells, highlightsInsertedRows, insertedRowHighlightColor, insertedRowKeySet, isVirtualized, metrics, rowDragPreview, rowHeight, rows, selectedColumnKeySet, selectedRowKeySet, selection, selectionRange, sortState, stripedColor, viewport.width, virtualOverscan]);
+    paintGrid({ context, width: viewport.width, height: renderHeight, pixelRatio: ratio, scrollLeft: scroll.left, scrollTop: scroll.top, rowHeight, headerHeight, headerLeafTop, headerLeafHeight, bodyTop, suppressLastRowBottomBorder: bottomSummaryHeight > 0, suppressFrameBottomBorder: bottomSummaryHeight > 0, fixedHeader, verticalBorderless: !hasVerticalBorders, striped: hasStripedRows, columnDraggable, sortState, filterValues, hoveredHeaderAction: hoveredHeaderActionRef.current, rows, columns, metrics, range, selection, editing, hoveredRowIndex: hoveredRowIndexRef.current, selectionRange, selectedRowKeys: selectedRowKeySet, selectedColumnKeys: selectedColumnKeySet, cellSpans: cellSpanLookup.covered, maxRowSpan: cellSpanLookup.maxRowSpan, highlightEditedCells: highlightsEditedCells, highlightInsertedRows: highlightsInsertedRows, insertedRowKeys: insertedRowKeySet, editedCellKeys, cellAnnotations, getRowKey, rowDragPreview, colors: themeColors });
+  }, [bodyTop, bodyViewportHeight, bottomSummaryHeight, cellAnnotations, cellSpanLookup, columnDraggable, columns, editedCellHighlightColor, editedCellKeys, editing, renderHeight, filterValues, fixedHeader, getRowKey, hasStripedRows, hasVerticalBorders, headerDepth, headerHeight, headerLeafHeight, headerLeafTop, highlightsEditedCells, highlightsInsertedRows, insertedRowHighlightColor, insertedRowKeySet, isVirtualized, metrics, rowDragPreview, rowHeight, rows, selectedColumnKeySet, selectedRowKeySet, selection, selectionRange, sortState, stripedColor, viewport.width, virtualOverscan]);
   const scheduleDraw = useCallback2(() => {
     if (frameRef.current === null) frameRef.current = requestAnimationFrame(draw);
   }, [draw]);
+  const drawImmediately = useCallback2(() => {
+    if (frameRef.current !== null) cancelAnimationFrame(frameRef.current);
+    frameRef.current = null;
+    draw();
+  }, [draw]);
+  const getSelectionHorizontalVisibility = useCallback2((scrollLeft) => {
+    if (!selection || selectionRange) return "visible";
+    const column = columns[selection.columnIndex];
+    if (!column || column.fixed !== void 0) return "visible";
+    const span = getCellSpan(selection.rowIndex, selection.columnIndex);
+    const left = getScrollableColumnLeft(selection.columnIndex) - scrollLeft;
+    const right = left + getCellDisplayWidth(selection.columnIndex, span?.colSpan ?? 1);
+    if (right <= fixedWidth) return "hidden-left";
+    if (left >= viewport.width - rightFixedWidth) return "hidden-right";
+    return "visible";
+  }, [columns, fixedWidth, getCellDisplayWidth, getCellSpan, getScrollableColumnLeft, rightFixedWidth, selection, selectionRange, viewport.width]);
+  const getSelectionEdgeIndicator = useCallback2((scrollLeft, scrollTop) => {
+    if (!selection || selectionRange) return null;
+    const row = rows[selection.rowIndex];
+    const metric = metrics[selection.columnIndex];
+    const column = columns[selection.columnIndex];
+    if (!row || !metric || !column || getRowKey(row, selection.rowIndex) !== selection.rowKey) return null;
+    const span = getCellSpan(selection.rowIndex, selection.columnIndex);
+    const rawLeft = column.fixed === "left" ? leftFixedOffsets.get(selection.columnIndex) ?? 0 : column.fixed === "right" ? viewport.width - (rightFixedOffsets.get(selection.columnIndex) ?? 0) - metric.width : getScrollableColumnLeft(selection.columnIndex) - scrollLeft;
+    const rawRight = rawLeft + getCellDisplayWidth(selection.columnIndex, span?.colSpan ?? 1);
+    const rawTop = bodyTop + selection.rowIndex * rowHeight - scrollTop;
+    const rawBottom = rawTop + rowHeight * (span?.rowSpan ?? 1);
+    const horizontalStart = column.fixed === void 0 ? fixedWidth : 0;
+    const horizontalEnd = column.fixed === void 0 ? viewport.width - rightFixedWidth : viewport.width;
+    const verticalStart = fixedHeader ? bodyTop : 0;
+    const hiddenLeft = column.fixed === void 0 && rawRight <= horizontalStart;
+    const hiddenRight = column.fixed === void 0 && rawLeft >= horizontalEnd;
+    const hiddenTop = rawBottom <= verticalStart;
+    const hiddenBottom = rawTop >= renderHeight;
+    if (!hiddenLeft && !hiddenRight && !hiddenTop && !hiddenBottom) return null;
+    const borderWidth = 2;
+    const cornerLength = 10;
+    const hitSlop = 6;
+    const targetSize = borderWidth + hitSlop * 2;
+    const rightBoundaryInset = rightFixedWidth > 0 && hasVerticalBorders ? 1 : 0;
+    const markerX = hiddenLeft ? horizontalStart : horizontalEnd - borderWidth - rightBoundaryInset;
+    const markerY = hiddenTop ? verticalStart : renderHeight - borderWidth;
+    if (hiddenLeft || hiddenRight) {
+      let markerTop = Math.max(rawTop - borderWidth, verticalStart);
+      let markerBottom = Math.min(rawBottom + 1, renderHeight);
+      const topClip = Math.max(0, verticalStart - (rawTop - borderWidth));
+      const bottomClip = Math.max(0, rawBottom + 1 - renderHeight);
+      if (topClip > 0 || bottomClip > 0) {
+        const foldAtTop = topClip > 0;
+        const fold = Math.min(cornerLength, foldAtTop ? topClip : bottomClip);
+        if (fold > borderWidth) {
+          const cornerWidth = fold;
+          const cornerHeight = Math.max(cornerLength, markerBottom - markerTop);
+          const cornerOnLeft = hiddenLeft;
+          const shapeLeft = cornerOnLeft ? markerX : markerX + borderWidth - cornerWidth;
+          const shapeTop = foldAtTop ? verticalStart : renderHeight - cornerHeight;
+          return {
+            side: `${foldAtTop ? "top" : "bottom"}-${cornerOnLeft ? "left" : "right"}`,
+            orientation: "corner",
+            style: {
+              left: shapeLeft - hitSlop,
+              top: shapeTop - hitSlop,
+              width: cornerWidth + hitSlop * 2,
+              height: cornerHeight + hitSlop * 2
+            },
+            corner: { width: cornerWidth, height: cornerHeight }
+          };
+        }
+      }
+      if (markerBottom <= markerTop) return null;
+      return {
+        side: hiddenLeft ? "left" : "right",
+        orientation: "vertical",
+        viewportEdge: hiddenLeft && horizontalStart === 0 ? "left" : hiddenRight && horizontalEnd === viewport.width ? "right" : void 0,
+        style: {
+          left: markerX - hitSlop,
+          top: markerTop,
+          width: targetSize,
+          height: markerBottom - markerTop
+        }
+      };
+    }
+    const horizontalMarkerEnd = horizontalEnd - rightBoundaryInset;
+    let markerLeft = Math.max(rawLeft - borderWidth, horizontalStart);
+    let markerRight = Math.min(rawRight + 1, horizontalMarkerEnd);
+    const leftClip = Math.max(0, horizontalStart - (rawLeft - borderWidth));
+    const rightClip = Math.max(0, rawRight + 1 - horizontalMarkerEnd);
+    if (leftClip > 0 || rightClip > 0) {
+      const foldAtLeft = leftClip > 0;
+      const fold = Math.min(cornerLength, foldAtLeft ? leftClip : rightClip);
+      if (fold > borderWidth) {
+        const cornerWidth = Math.max(cornerLength, markerRight - markerLeft);
+        const cornerHeight = fold;
+        const shapeLeft = foldAtLeft ? horizontalStart : horizontalMarkerEnd - cornerWidth;
+        const shapeTop = hiddenTop ? verticalStart : renderHeight - cornerHeight;
+        return {
+          side: `${hiddenTop ? "top" : "bottom"}-${foldAtLeft ? "left" : "right"}`,
+          orientation: "corner",
+          style: {
+            left: shapeLeft - hitSlop,
+            top: shapeTop - hitSlop,
+            width: cornerWidth + hitSlop * 2,
+            height: cornerHeight + hitSlop * 2
+          },
+          corner: { width: cornerWidth, height: cornerHeight }
+        };
+      }
+    }
+    if (markerRight <= markerLeft) return null;
+    return {
+      side: hiddenTop ? "top" : "bottom",
+      orientation: "horizontal",
+      viewportEdge: hiddenTop && verticalStart === 0 ? "top" : hiddenBottom ? "bottom" : void 0,
+      style: {
+        left: markerLeft,
+        top: markerY - hitSlop,
+        width: markerRight - markerLeft,
+        height: targetSize
+      }
+    };
+  }, [bodyTop, columns, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, getRowKey, getScrollableColumnLeft, hasVerticalBorders, leftFixedOffsets, metrics, renderHeight, rightFixedOffsets, rightFixedWidth, rowHeight, rows, selection, selectionRange, viewport.width]);
+  const syncSelectionEdgeTarget = useCallback2((scrollLeft, scrollTop) => {
+    const target = selectionEdgeTargetRef.current;
+    if (!target) return;
+    const indicator = getSelectionEdgeIndicator(scrollLeft, scrollTop);
+    if (!indicator) {
+      target.style.visibility = "hidden";
+      return;
+    }
+    const orientationChanged = !target.classList.contains(`is-${indicator.orientation}`);
+    target.className = `rvg-selection-edge-target is-${indicator.orientation} is-${indicator.side}${indicator.viewportEdge ? ` is-viewport-${indicator.viewportEdge}` : ""}${orientationChanged ? " is-shape-syncing" : ""}`;
+    target.style.left = `${Number(indicator.style.left)}px`;
+    target.style.top = `${Number(indicator.style.top)}px`;
+    target.style.width = `${Number(indicator.style.width)}px`;
+    target.style.height = `${Number(indicator.style.height)}px`;
+    if (indicator.corner) {
+      target.style.setProperty("--rvg-corner-width", `${indicator.corner.width}px`);
+      target.style.setProperty("--rvg-corner-height", `${indicator.corner.height}px`);
+      target.style.setProperty("--rvg-corner-hover-width-extension", "4px");
+      target.style.setProperty("--rvg-corner-hover-height-extension", "4px");
+    } else {
+      target.style.removeProperty("--rvg-corner-width");
+      target.style.removeProperty("--rvg-corner-height");
+      target.style.removeProperty("--rvg-corner-hover-width-extension");
+      target.style.removeProperty("--rvg-corner-hover-height-extension");
+    }
+    target.style.visibility = "visible";
+    if (orientationChanged) {
+      void target.offsetWidth;
+      target.classList.remove("is-shape-syncing");
+    }
+  }, [getSelectionEdgeIndicator]);
   useLayoutEffect2(() => {
     const element = scrollerRef.current;
     if (!element) return;
@@ -1811,6 +2122,8 @@ function Table({
     if (sortDebounceRef.current !== null) clearTimeout(sortDebounceRef.current);
     if (textFrameRef.current !== null) cancelAnimationFrame(textFrameRef.current);
     if (toastTimerRef.current !== null) clearTimeout(toastTimerRef.current);
+    if (verticalScrollbarVisibilityTimerRef.current !== null) clearTimeout(verticalScrollbarVisibilityTimerRef.current);
+    if (horizontalScrollbarVisibilityTimerRef.current !== null) clearTimeout(horizontalScrollbarVisibilityTimerRef.current);
   }, []);
   useEffect2(() => {
     const scroller = scrollerRef.current;
@@ -1862,10 +2175,218 @@ function Table({
     scroller.addEventListener("scroll", lockScroll);
     return () => scroller.removeEventListener("scroll", lockScroll);
   }, [insertBusy]);
+  const showCustomScrollbar = useCallback2((axis, persist = false) => {
+    const showVertical = axis === "vertical" || axis === "both";
+    const showHorizontal = axis === "horizontal" || axis === "both";
+    if (showVertical) {
+      verticalScrollbarRef.current?.classList.add("is-active");
+      if (verticalScrollbarVisibilityTimerRef.current !== null) clearTimeout(verticalScrollbarVisibilityTimerRef.current);
+      if (!persist) {
+        verticalScrollbarVisibilityTimerRef.current = setTimeout(() => {
+          verticalScrollbarRef.current?.classList.remove("is-active");
+          verticalScrollbarVisibilityTimerRef.current = null;
+        }, 900);
+      }
+    }
+    if (showHorizontal) {
+      horizontalScrollbarRef.current?.classList.add("is-active");
+      if (horizontalScrollbarVisibilityTimerRef.current !== null) clearTimeout(horizontalScrollbarVisibilityTimerRef.current);
+      if (!persist) {
+        horizontalScrollbarVisibilityTimerRef.current = setTimeout(() => {
+          horizontalScrollbarRef.current?.classList.remove("is-active");
+          horizontalScrollbarVisibilityTimerRef.current = null;
+        }, 900);
+      }
+    }
+  }, []);
+  const keepCustomScrollbarVisible = useCallback2((axis) => {
+    showCustomScrollbar(axis, true);
+  }, [showCustomScrollbar]);
+  const releaseCustomScrollbarVisible = useCallback2((axis) => {
+    if (axis === "vertical" && verticalScrollbarDragRef.current) return;
+    if (axis === "horizontal" && horizontalScrollbarDragRef.current) return;
+    showCustomScrollbar(axis);
+  }, [showCustomScrollbar]);
+  const updateCustomScrollbars = useCallback2(() => {
+    const scroller = scrollerRef.current;
+    const verticalTrack = verticalScrollbarRef.current;
+    const verticalThumb = verticalScrollbarThumbRef.current;
+    const horizontalTrack = horizontalScrollbarRef.current;
+    const horizontalThumb = horizontalScrollbarThumbRef.current;
+    if (!scroller || !verticalTrack || !verticalThumb || !horizontalTrack || !horizontalThumb) return;
+    const maxScrollTop = scroller.scrollHeight - scroller.clientHeight;
+    if (maxScrollTop <= 1 || renderHeight <= 0) {
+      verticalTrack.style.display = "none";
+    } else {
+      const top = fixedHeader ? bodyTop : 0;
+      const bottom = bottomSummaryHeight;
+      const trackHeight = Math.max(0, effectiveHeight - top - bottom);
+      if (trackHeight <= 0) {
+        verticalTrack.style.display = "none";
+      } else {
+        const thumbHeight = Math.max(28, Math.round(trackHeight * (scroller.clientHeight / scroller.scrollHeight)));
+        const maxThumbTop = Math.max(0, trackHeight - thumbHeight);
+        const thumbTop = maxScrollTop > 0 ? Math.round(scroller.scrollTop / maxScrollTop * maxThumbTop) : 0;
+        verticalTrack.style.display = "block";
+        verticalTrack.style.top = `${top}px`;
+        verticalTrack.style.bottom = `${bottom}px`;
+        verticalThumb.style.height = `${Math.min(trackHeight, thumbHeight)}px`;
+        verticalThumb.style.transform = `translateY(${thumbTop}px)`;
+      }
+    }
+    const maxScrollLeft = scroller.scrollWidth - scroller.clientWidth;
+    if (maxScrollLeft <= 1 || viewport.width <= 0) {
+      horizontalTrack.style.display = "none";
+      return;
+    }
+    const trackLeft = fixedWidth;
+    const trackRight = rightFixedWidth;
+    const trackWidth = Math.max(0, viewport.width - trackLeft - trackRight);
+    if (trackWidth <= 0) {
+      horizontalTrack.style.display = "none";
+      return;
+    }
+    const thumbWidth = Math.max(36, Math.round(trackWidth * (scroller.clientWidth / scroller.scrollWidth)));
+    const maxThumbLeft = Math.max(0, trackWidth - thumbWidth);
+    const thumbLeft = maxScrollLeft > 0 ? Math.round(scroller.scrollLeft / maxScrollLeft * maxThumbLeft) : 0;
+    horizontalTrack.style.display = "block";
+    horizontalTrack.style.left = `${trackLeft}px`;
+    horizontalTrack.style.right = `${trackRight}px`;
+    horizontalTrack.style.bottom = `${bottomSummaryHeight + 2}px`;
+    horizontalThumb.style.width = `${Math.min(trackWidth, thumbWidth)}px`;
+    horizontalThumb.style.transform = `translateX(${thumbLeft}px)`;
+  }, [bodyTop, bottomSummaryHeight, effectiveHeight, fixedHeader, fixedWidth, renderHeight, rightFixedWidth, viewport.width]);
+  useLayoutEffect2(() => {
+    updateCustomScrollbars();
+  }, [contentHeight, contentWidth, updateCustomScrollbars, viewport.height, viewport.width]);
+  const handleVerticalScrollbarPointerDown = useCallback2((event) => {
+    const scroller = scrollerRef.current;
+    const track = verticalScrollbarRef.current;
+    const thumb = verticalScrollbarThumbRef.current;
+    if (!scroller || !track || !thumb || event.button !== 0) return;
+    event.preventDefault();
+    event.currentTarget.setPointerCapture(event.pointerId);
+    const trackRect = track.getBoundingClientRect();
+    const thumbRect = thumb.getBoundingClientRect();
+    const maxScrollTop = scroller.scrollHeight - scroller.clientHeight;
+    const trackHeight = trackRect.height;
+    const thumbHeight = thumbRect.height;
+    showCustomScrollbar("vertical", true);
+    if (event.target === thumb) {
+      verticalScrollbarDragRef.current = {
+        pointerId: event.pointerId,
+        startY: event.clientY,
+        startTop: thumbRect.top - trackRect.top,
+        trackHeight,
+        thumbHeight,
+        maxScrollTop
+      };
+      return;
+    }
+    const nextThumbTop = Math.max(0, Math.min(trackHeight - thumbHeight, event.clientY - trackRect.top - thumbHeight / 2));
+    const maxThumbTop = Math.max(1, trackHeight - thumbHeight);
+    scroller.scrollTop = nextThumbTop / maxThumbTop * maxScrollTop;
+    updateCustomScrollbars();
+    verticalScrollbarDragRef.current = {
+      pointerId: event.pointerId,
+      startY: event.clientY,
+      startTop: nextThumbTop,
+      trackHeight,
+      thumbHeight,
+      maxScrollTop
+    };
+  }, [showCustomScrollbar, updateCustomScrollbars]);
+  const handleVerticalScrollbarPointerMove = useCallback2((event) => {
+    const drag = verticalScrollbarDragRef.current;
+    const scroller = scrollerRef.current;
+    if (!drag || !scroller || drag.pointerId !== event.pointerId) return;
+    event.preventDefault();
+    const maxThumbTop = Math.max(1, drag.trackHeight - drag.thumbHeight);
+    const nextThumbTop = Math.max(0, Math.min(maxThumbTop, drag.startTop + event.clientY - drag.startY));
+    scroller.scrollTop = nextThumbTop / maxThumbTop * drag.maxScrollTop;
+    updateCustomScrollbars();
+  }, [updateCustomScrollbars]);
+  const handleVerticalScrollbarPointerUp = useCallback2((event) => {
+    const drag = verticalScrollbarDragRef.current;
+    if (!drag || drag.pointerId !== event.pointerId) return;
+    if (event.currentTarget.hasPointerCapture(event.pointerId)) event.currentTarget.releasePointerCapture(event.pointerId);
+    verticalScrollbarDragRef.current = null;
+    showCustomScrollbar("vertical");
+  }, [showCustomScrollbar]);
+  const handleHorizontalScrollbarPointerDown = useCallback2((event) => {
+    const scroller = scrollerRef.current;
+    const track = horizontalScrollbarRef.current;
+    const thumb = horizontalScrollbarThumbRef.current;
+    if (!scroller || !track || !thumb || event.button !== 0) return;
+    event.preventDefault();
+    event.currentTarget.setPointerCapture(event.pointerId);
+    const trackRect = track.getBoundingClientRect();
+    const thumbRect = thumb.getBoundingClientRect();
+    const maxScrollLeft = scroller.scrollWidth - scroller.clientWidth;
+    const trackWidth = trackRect.width;
+    const thumbWidth = thumbRect.width;
+    showCustomScrollbar("horizontal", true);
+    if (event.target === thumb) {
+      horizontalScrollbarDragRef.current = {
+        pointerId: event.pointerId,
+        startX: event.clientX,
+        startLeft: thumbRect.left - trackRect.left,
+        trackWidth,
+        thumbWidth,
+        maxScrollLeft
+      };
+      return;
+    }
+    const nextThumbLeft = Math.max(0, Math.min(trackWidth - thumbWidth, event.clientX - trackRect.left - thumbWidth / 2));
+    const maxThumbLeft = Math.max(1, trackWidth - thumbWidth);
+    const previousScrollLeft = scroller.scrollLeft;
+    const nextScrollLeft = nextThumbLeft / maxThumbLeft * maxScrollLeft;
+    const visibilityChanged = getSelectionHorizontalVisibility(previousScrollLeft) !== getSelectionHorizontalVisibility(nextScrollLeft);
+    scroller.scrollLeft = nextScrollLeft;
+    scrollRef.current = { left: scroller.scrollLeft, top: scroller.scrollTop };
+    syncSelectionEdgeTarget(scroller.scrollLeft, scroller.scrollTop);
+    if (visibilityChanged) drawImmediately();
+    updateCustomScrollbars();
+    horizontalScrollbarDragRef.current = {
+      pointerId: event.pointerId,
+      startX: event.clientX,
+      startLeft: nextThumbLeft,
+      trackWidth,
+      thumbWidth,
+      maxScrollLeft
+    };
+  }, [drawImmediately, getSelectionHorizontalVisibility, showCustomScrollbar, syncSelectionEdgeTarget, updateCustomScrollbars]);
+  const handleHorizontalScrollbarPointerMove = useCallback2((event) => {
+    const drag = horizontalScrollbarDragRef.current;
+    const scroller = scrollerRef.current;
+    if (!drag || !scroller || drag.pointerId !== event.pointerId) return;
+    event.preventDefault();
+    const maxThumbLeft = Math.max(1, drag.trackWidth - drag.thumbWidth);
+    const nextThumbLeft = Math.max(0, Math.min(maxThumbLeft, drag.startLeft + event.clientX - drag.startX));
+    const previousScrollLeft = scroller.scrollLeft;
+    const nextScrollLeft = nextThumbLeft / maxThumbLeft * drag.maxScrollLeft;
+    const visibilityChanged = getSelectionHorizontalVisibility(previousScrollLeft) !== getSelectionHorizontalVisibility(nextScrollLeft);
+    scroller.scrollLeft = nextScrollLeft;
+    scrollRef.current = { left: scroller.scrollLeft, top: scroller.scrollTop };
+    syncSelectionEdgeTarget(scroller.scrollLeft, scroller.scrollTop);
+    if (visibilityChanged) drawImmediately();
+    updateCustomScrollbars();
+  }, [drawImmediately, getSelectionHorizontalVisibility, syncSelectionEdgeTarget, updateCustomScrollbars]);
+  const handleHorizontalScrollbarPointerUp = useCallback2((event) => {
+    const drag = horizontalScrollbarDragRef.current;
+    if (!drag || drag.pointerId !== event.pointerId) return;
+    if (event.currentTarget.hasPointerCapture(event.pointerId)) event.currentTarget.releasePointerCapture(event.pointerId);
+    horizontalScrollbarDragRef.current = null;
+    showCustomScrollbar("horizontal");
+  }, [showCustomScrollbar]);
   const handleScroll = useCallback2(() => {
     const element = scrollerRef.current;
     if (!element) return;
+    const previousScroll = scrollRef.current;
+    const scrollDeltaX = element.scrollLeft - previousScroll.left;
+    const scrollDeltaY = element.scrollTop - previousScroll.top;
     scrollRef.current = { left: element.scrollLeft, top: element.scrollTop };
+    syncSelectionEdgeTarget(element.scrollLeft, element.scrollTop);
     const focus = selectionFocusRef.current;
     if (focus && selection && !selectionRange) {
       const row = rows[selection.rowIndex];
@@ -1875,7 +2396,7 @@ function Table({
       if (!validSelection) {
         focus.style.display = "none";
       } else {
-        const rawLeft = column.fixed === "left" ? metric.left : column.fixed === "right" ? viewport.width - (rightFixedOffsets.get(selection.columnIndex) ?? 0) - metric.width : metric.left - element.scrollLeft;
+        const rawLeft = column.fixed === "left" ? leftFixedOffsets.get(selection.columnIndex) ?? 0 : column.fixed === "right" ? viewport.width - (rightFixedOffsets.get(selection.columnIndex) ?? 0) - metric.width : getScrollableColumnLeft(selection.columnIndex) - element.scrollLeft;
         const rawTop = bodyTop + selection.rowIndex * rowHeight - element.scrollTop;
         const span = getCellSpan(selection.rowIndex, selection.columnIndex);
         const rawRight = rawLeft + getCellDisplayWidth(selection.columnIndex, span?.colSpan ?? 1);
@@ -1887,9 +2408,9 @@ function Table({
           focus.style.display = "none";
         } else {
           const borderWidth = 2;
-          const left = Math.round(Math.max(rawLeft - borderWidth, horizontalStart - 1));
+          const left = Math.round(Math.max(rawLeft - borderWidth, horizontalStart));
           const right = Math.round(Math.min(rawRight + 1, horizontalEnd, viewport.width));
-          const top = Math.round(Math.max(rawTop - borderWidth, verticalStart - 1));
+          const top = Math.round(Math.max(rawTop - borderWidth, verticalStart));
           const bottom = Math.round(Math.min(rawBottom + 1, renderHeight));
           focus.style.display = "block";
           focus.style.left = `${left}px`;
@@ -1908,6 +2429,10 @@ function Table({
     if (scrollingTextRef.current) scrollingTextRef.current.style.transform = `translateX(${-element.scrollLeft}px)`;
     if (scrollingHeaderIconsRef.current) scrollingHeaderIconsRef.current.style.transform = `translateX(${-element.scrollLeft}px)`;
     if (headerIconsRef.current) headerIconsRef.current.style.transform = `translateY(${fixedHeader ? 0 : -element.scrollTop}px)`;
+    updateCustomScrollbars();
+    if (scrollDeltaX !== 0 || scrollDeltaY !== 0) {
+      showCustomScrollbar(scrollDeltaX !== 0 && scrollDeltaY !== 0 ? "both" : scrollDeltaX !== 0 ? "horizontal" : "vertical");
+    }
     if (hoveredHeaderActionRef.current) {
       hoveredHeaderActionRef.current = null;
       setHoveredHeaderAction(null);
@@ -1915,7 +2440,7 @@ function Table({
     setHoveredCellTooltip(null);
     scheduleDraw();
     setEditing(null);
-  }, [bodyTop, columns, renderHeight, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, getRowKey, metrics, rightFixedOffsets, rightFixedWidth, rowHeight, rows, scheduleDraw, selection, selectionRange, viewport.width]);
+  }, [bodyTop, columns, renderHeight, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, getRowKey, getScrollableColumnLeft, metrics, rightFixedOffsets, rightFixedWidth, rowHeight, rows, scheduleDraw, selection, selectionRange, showCustomScrollbar, syncSelectionEdgeTarget, updateCustomScrollbars, viewport.width]);
   const locateColumn = useCallback2((clientX) => {
     const canvas = canvasRef.current;
     if (!canvas) return -1;
@@ -1923,7 +2448,11 @@ function Table({
     const localX = clientX - rect.left;
     let columnIndex;
     if (localX < fixedWidth) {
-      columnIndex = hitTestColumn(metrics, localX);
+      columnIndex = columns.findIndex((column, index) => {
+        if (column.fixed !== "left") return false;
+        const left = leftFixedOffsets.get(index) ?? 0;
+        return localX >= left && localX < left + metrics[index].width;
+      });
     } else if (rightFixedWidth > 0 && localX >= viewport.width - rightFixedWidth) {
       columnIndex = columns.findIndex((column, index) => {
         if (column.fixed !== "right") return false;
@@ -1931,41 +2460,33 @@ function Table({
         return localX >= left && localX < left + metrics[index].width;
       });
     } else {
-      columnIndex = hitTestColumn(metrics, localX + scrollRef.current.left);
+      const scrollX = localX + scrollRef.current.left;
+      columnIndex = columns.findIndex((column, index) => {
+        if (column.fixed !== void 0) return false;
+        const left = getScrollableColumnLeft(index);
+        return scrollX >= left && scrollX < left + metrics[index].width;
+      });
     }
     return columnIndex;
-  }, [columns, fixedWidth, metrics, rightFixedOffsets, rightFixedWidth, viewport.width]);
+  }, [columns, fixedWidth, getScrollableColumnLeft, leftFixedOffsets, metrics, rightFixedOffsets, rightFixedWidth, viewport.width]);
   const getDisplayedColumnLeft = useCallback2((columnIndex) => {
     const metric = metrics[columnIndex];
-    if (columns[columnIndex].fixed === "left") return metric.left;
+    if (columns[columnIndex].fixed === "left") return leftFixedOffsets.get(columnIndex) ?? 0;
     if (columns[columnIndex].fixed === "right") return viewport.width - (rightFixedOffsets.get(columnIndex) ?? 0) - metric.width;
-    return metric.left - scrollRef.current.left;
-  }, [columns, metrics, rightFixedOffsets, viewport.width]);
-  const locateResizeHandle = useCallback2((clientX) => {
-    if (!columnResizable || !canvasRef.current) return -1;
-    const localX = clientX - canvasRef.current.getBoundingClientRect().left;
-    let closest = -1;
-    let distance = 6;
-    for (let index = 0; index < columns.length; index += 1) {
-      if (columns[index].rowSelection || columns[index].rowDragHandle || columns[index].rowNumber) continue;
-      const nextDistance = Math.abs(localX - (getDisplayedColumnLeft(index) + metrics[index].width));
-      if (nextDistance < distance) {
-        distance = nextDistance;
-        closest = index;
-      }
-    }
-    return closest;
-  }, [columnResizable, columns, getDisplayedColumnLeft, metrics]);
-  const findResizeNeighbor = useCallback2((columnIndex) => {
-    const resizedColumn = columns[columnIndex];
-    for (let index = columnIndex + 1; index < columns.length; index += 1) {
-      const column = columns[index];
-      if (column.rowSelection || column.rowDragHandle || column.rowNumber) continue;
-      if (resizedColumn?.fixed && column.fixed !== resizedColumn.fixed) return -1;
-      return index;
+    return getScrollableColumnLeft(columnIndex) - scrollRef.current.left;
+  }, [columns, getScrollableColumnLeft, leftFixedOffsets, metrics, rightFixedOffsets, viewport.width]);
+  const getHeaderLevelAtY = useCallback2((localY, headerY) => {
+    const y = localY - headerY;
+    for (let level = 0; level < headerRowHeights.length; level += 1) {
+      const top = headerRowOffsets[level] ?? 0;
+      if (y >= top && y < top + headerRowHeights[level]) return level;
     }
-    return -1;
-  }, [columns]);
+    return headerDepth - 1;
+  }, [headerDepth, headerRowHeights, headerRowOffsets]);
+  const resizeColumn = useCallback2((columnKey, width2) => {
+    setResizedColumnWidths((current) => current[columnKey] === width2 ? current : { ...current, [columnKey]: width2 });
+    onColumnResize?.(columnKey, width2);
+  }, [onColumnResize]);
   const locateHeaderAction = useCallback2((clientX, columnIndex) => {
     if (columnIndex < 0 || !canvasRef.current) return null;
     const column = columns[columnIndex];
@@ -2000,11 +2521,97 @@ function Table({
     const columnRight = getDisplayedColumnLeft(columnIndex) + metrics[columnIndex].width;
     return localX >= columnRight - 16 && localX < columnRight - 5;
   }, [columnDraggable, columns, getDisplayedColumnLeft, measureHeaderTitleWidth, metrics]);
-  const setDragGuide = useCallback2((x) => {
+  const getHeaderCellLeft = useCallback2((cell) => {
+    const startMetric = metrics[cell.startIndex];
+    const fixedSide = columns[cell.startIndex]?.fixed;
+    if (!startMetric) return 0;
+    return fixedSide === "left" ? leftFixedOffsets.get(cell.startIndex) ?? 0 : fixedSide === "right" ? viewport.width - (rightFixedOffsets.get(cell.startIndex) ?? 0) - startMetric.width : getScrollableColumnLeft(cell.startIndex) - scrollRef.current.left;
+  }, [columns, getScrollableColumnLeft, leftFixedOffsets, metrics, rightFixedOffsets, viewport.width]);
+  const getHeaderCellWidth = useCallback2((cell) => cell.leaf ? metrics[cell.startIndex]?.width ?? 0 : getCellDisplayWidth(cell.startIndex, cell.endIndex - cell.startIndex + 1), [getCellDisplayWidth, metrics]);
+  const getHeaderCellEdgeFromMetrics = useCallback2((startIndex, endIndex, edge, nextMetrics) => {
+    const fixedSide = columns[startIndex]?.fixed;
+    const width2 = nextMetrics.slice(startIndex, endIndex + 1).reduce((total, metric) => total + metric.width, 0);
+    let left;
+    if (fixedSide === "left") {
+      left = 0;
+      for (let index = 0; index < startIndex; index += 1) {
+        if (columns[index].fixed === "left") left += nextMetrics[index]?.width ?? 0;
+      }
+    } else if (fixedSide === "right") {
+      let rightOffset = 0;
+      for (let index = columns.length - 1; index > startIndex; index -= 1) {
+        if (columns[index].fixed === "right") rightOffset += nextMetrics[index]?.width ?? 0;
+      }
+      left = viewport.width - rightOffset - width2;
+    } else {
+      left = 0;
+      for (let index = 0; index < startIndex; index += 1) {
+        if (columns[index].fixed === void 0) left += nextMetrics[index]?.width ?? 0;
+      }
+      left += fixedWidth - scrollRef.current.left;
+    }
+    return left + (edge === "right" ? width2 : 0);
+  }, [columns, fixedWidth, viewport.width]);
+  const locateHeaderResizeHit = useCallback2((clientX, clientY) => {
+    if (!columnResizable || !canvasRef.current) return null;
+    const rect = canvasRef.current.getBoundingClientRect();
+    const localX = clientX - rect.left;
+    const localY = clientY - rect.top;
+    const headerY = fixedHeader ? 0 : -scrollRef.current.top;
+    if (localY < headerY || localY >= headerY + headerHeight) return null;
+    const level = getHeaderLevelAtY(localY, headerY);
+    let closest = null;
+    let distance = 6;
+    let priority = -1;
+    for (const cell of headerCells) {
+      if (cell.level !== level) continue;
+      if (columns[cell.startIndex]?.rowSelection || columns[cell.startIndex]?.rowDragHandle || columns[cell.startIndex]?.rowNumber) continue;
+      const fixedSide = columns[cell.startIndex]?.fixed;
+      const edge = fixedSide === "right" && cell.leaf ? "left" : "right";
+      const edgeX = getHeaderCellLeft(cell) + (edge === "right" ? getHeaderCellWidth(cell) : 0);
+      const nextDistance = Math.abs(localX - edgeX);
+      const nextPriority = fixedSide === "right" ? 2 : fixedSide === "left" ? 1 : 0;
+      if (nextDistance < distance || nextDistance === distance && nextPriority > priority) {
+        distance = nextDistance;
+        priority = nextPriority;
+        closest = { cell, edge };
+      }
+    }
+    return closest;
+  }, [columnResizable, columns, fixedHeader, getHeaderCellLeft, getHeaderCellWidth, getHeaderLevelAtY, headerCells, headerHeight]);
+  const locateHeaderResizeCell = useCallback2((clientX, clientY) => locateHeaderResizeHit(clientX, clientY)?.cell ?? null, [locateHeaderResizeHit]);
+  const locateHeaderCellDragHandle = useCallback2((clientX, cell) => {
+    if (!columnDraggable || !canvasRef.current) return false;
+    if (cell.leaf) return locateHeaderDragHandle(clientX, cell.startIndex);
+    const localX = clientX - canvasRef.current.getBoundingClientRect().left;
+    const right = getHeaderCellLeft(cell) + getHeaderCellWidth(cell);
+    return localX >= right - 16 && localX < right - 5;
+  }, [columnDraggable, getHeaderCellLeft, getHeaderCellWidth, locateHeaderDragHandle]);
+  const locateHeaderCell = useCallback2((clientX, clientY) => {
+    const canvas = canvasRef.current;
+    if (!canvas) return null;
+    const rect = canvas.getBoundingClientRect();
+    const headerY = fixedHeader ? 0 : -scrollRef.current.top;
+    const localX = clientX - rect.left;
+    const localY = clientY - rect.top;
+    if (localY < headerY || localY >= headerY + headerHeight) return null;
+    const level = getHeaderLevelAtY(localY, headerY);
+    for (const cell of headerCells) {
+      if (cell.level !== level) continue;
+      const left = getHeaderCellLeft(cell);
+      const width2 = getHeaderCellWidth(cell);
+      if (localX >= left && localX < left + width2) return cell;
+    }
+    return null;
+  }, [fixedHeader, getHeaderCellLeft, getHeaderCellWidth, getHeaderLevelAtY, headerCells, headerHeight]);
+  const setDragGuide = useCallback2((x, top = 0) => {
     const guide = dragGuideRef.current;
     if (!guide) return;
     guide.style.display = x === null ? "none" : "block";
-    if (x !== null) guide.style.transform = `translateX(${Math.round(x)}px)`;
+    if (x !== null) {
+      guide.style.top = `${top}px`;
+      guide.style.transform = `translateX(${Math.round(x)}px)`;
+    }
   }, []);
   const setRowDragGuide = useCallback2((y) => {
     const guide = rowDragGuideRef.current;
@@ -2022,6 +2629,15 @@ function Table({
   useEffect2(() => {
     const canvas = canvasRef.current;
     if (!canvas || !columnDraggable && !rowDraggable) return;
+    const getColumnDropIndex = (sourceIndex, targetIndex, edge) => {
+      if (edge === "right") return targetIndex;
+      const destinationIndex = targetIndex - (sourceIndex < targetIndex ? 1 : 0);
+      return Math.max(0, Math.min(columns.length - 1, destinationIndex));
+    };
+    const getColumnDropPlacement = (sourceIndex, targetIndex, edge) => {
+      if (edge !== "right") return "before";
+      return targetIndex < sourceIndex ? "before" : "after";
+    };
     const getHeaderColumn = (clientX, clientY) => {
       const rect = canvas.getBoundingClientRect();
       const headerY = fixedHeader ? 0 : -scrollRef.current.top;
@@ -2029,22 +2645,35 @@ function Table({
       if (localY < headerY || localY >= headerY + headerHeight) return -1;
       return locateColumn(clientX);
     };
+    const getHeaderDragCell = (clientX, clientY) => {
+      const cell = locateHeaderCell(clientX, clientY);
+      if (!cell) return null;
+      return locateHeaderCellDragHandle(clientX, cell) && !locateHeaderResizeCell(clientX, clientY) ? cell : null;
+    };
     const cleanupDrag = draggable({
       element: canvas,
       canDrag: ({ input }) => {
-        const index = getHeaderColumn(input.clientX, input.clientY);
-        if (columnDraggable && index >= 0) return locateHeaderDragHandle(input.clientX, index) && locateResizeHandle(input.clientX) < 0;
+        const headerDragCell = columnDraggable ? getHeaderDragCell(input.clientX, input.clientY) : null;
+        if (headerDragCell) return true;
         const columnIndex = locateColumn(input.clientX);
         return rowDraggable && columnIndex >= 0 && Boolean(columns[columnIndex].rowDragHandle) && locateRow(input.clientY) >= 0;
       },
       getInitialData: ({ input }) => {
-        const headerColumn = getHeaderColumn(input.clientX, input.clientY);
-        if (headerColumn < 0) {
+        const headerDragCell = columnDraggable ? getHeaderDragCell(input.clientX, input.clientY) : null;
+        if (!headerDragCell) {
           return { type: "table-row", sourceIndex: locateRow(input.clientY) };
         }
-        const sourceIndex = headerColumn;
+        const sourceIndex = headerDragCell.startIndex;
         columnDragPreviewRef.current = { sourceIndex, targetIndex: sourceIndex };
-        return { type: "table-column", sourceIndex };
+        return {
+          type: "table-column",
+          sourceIndex,
+          sourceKey: headerDragCell.key,
+          parentKey: headerDragCell.parentKey,
+          headerLevel: headerDragCell.level,
+          headerKind: headerDragCell.leaf ? "column" : "group",
+          fixed: columns[headerDragCell.startIndex]?.fixed
+        };
       },
       onGenerateDragPreview: ({ nativeSetDragImage, source }) => {
         const sourceIndex = Number(source.data.sourceIndex);
@@ -2147,31 +2776,35 @@ function Table({
           return;
         }
         const targetIndex = Number(target?.targetIndex);
-        if (!Number.isInteger(targetIndex) || columns[targetIndex]?.fixed !== columns[sourceIndex]?.fixed) {
+        if (!Number.isInteger(targetIndex) || target?.headerKind !== source.data.headerKind || target?.parentKey !== source.data.parentKey || target?.fixed !== source.data.fixed) {
           setDragGuide(null);
           return;
         }
         const edge = target?.columnEdge;
-        let destinationIndex = targetIndex + (edge === "right" ? 1 : 0);
-        if (sourceIndex < destinationIndex) destinationIndex -= 1;
-        destinationIndex = Math.max(0, Math.min(columns.length - 1, destinationIndex));
+        const destinationIndex = getColumnDropIndex(sourceIndex, targetIndex, edge);
         columnDragPreviewRef.current = { sourceIndex, targetIndex: destinationIndex };
-        const targetLeft = getDisplayedColumnLeft(targetIndex);
-        setDragGuide(edge === "right" ? targetLeft + metrics[targetIndex].width : targetLeft);
+        const targetLeft = Number(target?.targetLeft);
+        const targetWidth = Number(target?.targetWidth);
+        if (!Number.isFinite(targetLeft) || !Number.isFinite(targetWidth)) {
+          setDragGuide(null);
+          return;
+        }
+        const guideTop = headerRowOffsets[Number(source.data.headerLevel)] ?? 0;
+        setDragGuide(edge === "right" ? targetLeft + targetWidth : targetLeft, guideTop);
       },
       onDrop: ({ source, location }) => {
         const target = location.current.dropTargets[0]?.data;
         const sourceIndex = Number(source.data.sourceIndex);
         if (source.data.type === "table-row") {
-          const rawTargetIndex = Number(target?.targetIndex);
-          let targetIndex2 = rawTargetIndex + (target?.rowEdge === "bottom" ? 1 : 0);
+          const rawTargetIndex2 = Number(target?.targetIndex);
+          let targetIndex2 = rawTargetIndex2 + (target?.rowEdge === "bottom" ? 1 : 0);
           if (sourceIndex < targetIndex2) targetIndex2 -= 1;
           targetIndex2 = Math.max(0, Math.min(rows.length - 1, targetIndex2));
           scrollerRef.current?.classList.add("rvg-row-drop-settling");
           setRowDragPreview(null);
           setRowDragGuide(null);
           canvas.style.cursor = "default";
-          if (Number.isInteger(rawTargetIndex) && sourceIndex !== targetIndex2) onRowOrderChange?.(sourceIndex, targetIndex2);
+          if (Number.isInteger(rawTargetIndex2) && sourceIndex !== targetIndex2) onRowOrderChange?.(sourceIndex, targetIndex2);
           requestAnimationFrame(() => {
             requestAnimationFrame(() => scrollerRef.current?.classList.remove("rvg-row-drop-settling"));
           });
@@ -2180,12 +2813,23 @@ function Table({
           }, 0);
           return;
         }
-        const targetIndex = columnDragPreviewRef.current?.targetIndex ?? Number(target?.targetIndex);
+        const rawTargetIndex = Number(target?.targetIndex);
+        const targetIndex = columnDragPreviewRef.current?.targetIndex ?? (Number.isInteger(rawTargetIndex) ? getColumnDropIndex(sourceIndex, rawTargetIndex, target?.columnEdge) : rawTargetIndex);
         canvas.style.cursor = "default";
         setDragGuide(null);
         columnDragPreviewRef.current = null;
-        if (Number.isInteger(targetIndex) && sourceIndex !== targetIndex && columns[targetIndex]?.fixed === columns[sourceIndex]?.fixed) {
-          onColumnOrderChange?.(sourceIndex - utilityColumnCount, targetIndex - utilityColumnCount);
+        if (Number.isInteger(rawTargetIndex) && Number.isInteger(targetIndex) && sourceIndex !== targetIndex && target?.headerKind === source.data.headerKind && target?.parentKey === source.data.parentKey && target?.fixed === source.data.fixed) {
+          onColumnOrderChange?.(
+            sourceIndex - utilityColumnCount,
+            targetIndex - utilityColumnCount,
+            {
+              type: source.data.headerKind === "group" ? "group" : "column",
+              sourceKey: String(source.data.sourceKey),
+              targetKey: String(target.targetKey),
+              parentKey: typeof source.data.parentKey === "string" ? source.data.parentKey : void 0,
+              placement: getColumnDropPlacement(sourceIndex, rawTargetIndex, target.columnEdge)
+            }
+          );
         }
         window.setTimeout(() => {
           suppressClickRef.current = false;
@@ -2203,24 +2847,38 @@ function Table({
           const rowEdge = input.clientY - canvas.getBoundingClientRect().top < rowTop + rowHeight / 2 ? "top" : "bottom";
           return attachClosestEdge({ targetIndex: targetIndex2, rowEdge }, { element, input, allowedEdges: ["top", "bottom"] });
         }
-        let targetIndex = getHeaderColumn(input.clientX, input.clientY);
-        if (targetIndex < 0) return { targetIndex: -1 };
+        const targetCell = locateHeaderCell(input.clientX, input.clientY);
+        if (!targetCell) return { targetIndex: -1 };
+        let targetIndex = targetCell.startIndex;
+        const targetFixed = columns[targetCell.startIndex]?.fixed;
+        const headerKind = targetCell.leaf ? "column" : "group";
+        if (source.data.headerKind !== headerKind || source.data.parentKey !== targetCell.parentKey || source.data.fixed !== targetFixed) return { targetIndex: -1 };
         if (columns[targetIndex].rowSelection || columns[targetIndex].rowDragHandle || columns[targetIndex].rowNumber) {
           const fixedSide = columns[Number(source.data.sourceIndex)]?.fixed;
           targetIndex = columns.findIndex((column, index) => index > targetIndex && column.fixed === fixedSide && !column.rowSelection && !column.rowDragHandle && !column.rowNumber);
           if (targetIndex < 0) return { targetIndex: -1 };
           return { targetIndex, columnEdge: "left" };
         }
-        const left = getDisplayedColumnLeft(targetIndex);
-        const columnEdge = input.clientX - canvas.getBoundingClientRect().left < left + metrics[targetIndex].width / 2 ? "left" : "right";
-        return attachClosestEdge({ targetIndex, columnEdge }, { element, input, allowedEdges: ["left", "right"] });
+        const left = getHeaderCellLeft(targetCell);
+        const targetWidth = targetCell.leaf ? metrics[targetIndex].width : getHeaderCellWidth(targetCell);
+        const columnEdge = input.clientX - canvas.getBoundingClientRect().left < left + targetWidth / 2 ? "left" : "right";
+        return attachClosestEdge({
+          targetIndex,
+          targetKey: targetCell.key,
+          parentKey: targetCell.parentKey,
+          headerKind,
+          fixed: targetFixed,
+          targetLeft: left,
+          targetWidth,
+          columnEdge
+        }, { element, input, allowedEdges: ["left", "right"] });
       }
     });
     return () => {
       cleanupDrag();
       cleanupDrop();
     };
-  }, [bodyTop, columnDraggable, columns, fixedHeader, getCellLabel, getDisplayedColumnLeft, getRowKey, headerHeight, locateColumn, locateHeaderDragHandle, locateResizeHandle, locateRow, metrics, onColumnOrderChange, onRowOrderChange, rowDraggable, rowHeight, rows, selectedRowKeySet, setDragGuide, setRowDragGuide, utilityColumnCount]);
+  }, [bodyTop, columnDraggable, columns, fixedHeader, getCellLabel, getDisplayedColumnLeft, getHeaderCellWidth, getRowKey, headerHeight, locateColumn, locateHeaderCell, locateHeaderCellDragHandle, locateHeaderResizeCell, locateRow, metrics, onColumnOrderChange, onRowOrderChange, rowDraggable, rowHeight, rows, selectedRowKeySet, setDragGuide, setRowDragGuide, utilityColumnCount]);
   const locateCell = useCallback2((clientX, clientY) => {
     const canvas = canvasRef.current;
     if (!canvas) return null;
@@ -2327,8 +2985,9 @@ function Table({
     const horizontalFocusGap = 0;
     const verticalFocusGap = 0;
     if (column.fixed === void 0) {
-      if (metric.left - nextLeft < fixedWidth) nextLeft = Math.max(0, metric.left - fixedWidth - horizontalFocusGap);
-      if (metric.left + cellWidth - nextLeft > viewport.width - rightFixedWidth) nextLeft = metric.left + cellWidth - viewport.width + rightFixedWidth + horizontalFocusGap;
+      const cellLeft = getScrollableColumnLeft(cell.columnIndex);
+      if (cellLeft - nextLeft < fixedWidth) nextLeft = Math.max(0, cellLeft - fixedWidth - horizontalFocusGap);
+      if (cellLeft + cellWidth - nextLeft > viewport.width - rightFixedWidth) nextLeft = cellLeft + cellWidth - viewport.width + rightFixedWidth + horizontalFocusGap;
     }
     const rowTop = (fixedHeader ? 0 : bodyTop) + cell.rowIndex * rowHeight;
     const rowBottom = rowTop + rowHeight * rowSpan;
@@ -2341,7 +3000,7 @@ function Table({
     scroller.scrollTop = nextTop;
     scrollRef.current = { left: scroller.scrollLeft, top: scroller.scrollTop };
     scheduleDraw();
-  }, [bodyTop, columns, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, metrics, rightFixedWidth, rowHeight, scheduleDraw, viewport.width]);
+  }, [bodyTop, columns, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, getScrollableColumnLeft, metrics, rightFixedWidth, rowHeight, scheduleDraw, viewport.width]);
   const beginEdit = useCallback2((cell) => {
     const column = columns[cell.columnIndex];
     if (!column?.editable || column.dataIndex === void 0) return;
@@ -2362,8 +3021,9 @@ function Table({
     const horizontalFocusGap = 0;
     const verticalFocusGap = 0;
     if (column.fixed === void 0) {
-      if (metric.left - nextLeft < fixedWidth) nextLeft = Math.max(0, metric.left - fixedWidth - horizontalFocusGap);
-      if (metric.left + cellWidth - nextLeft > viewport.width - rightFixedWidth) nextLeft = metric.left + cellWidth - viewport.width + rightFixedWidth + horizontalFocusGap;
+      const cellLeft = getScrollableColumnLeft(cell.columnIndex);
+      if (cellLeft - nextLeft < fixedWidth) nextLeft = Math.max(0, cellLeft - fixedWidth - horizontalFocusGap);
+      if (cellLeft + cellWidth - nextLeft > viewport.width - rightFixedWidth) nextLeft = cellLeft + cellWidth - viewport.width + rightFixedWidth + horizontalFocusGap;
     }
     const rowTop = (fixedHeader ? 0 : bodyTop) + cell.rowIndex * rowHeight;
     const rowBottom = rowTop + rowHeight * rowSpan;
@@ -2385,7 +3045,7 @@ function Table({
       return;
     }
     setEditing(cell);
-  }, [columns, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, metrics, rightFixedWidth, rowHeight, rows, scheduleDraw, viewport.width]);
+  }, [columns, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, getScrollableColumnLeft, metrics, rightFixedWidth, rowHeight, rows, scheduleDraw, viewport.width]);
   const getCellEditKey = (cell) => `${typeof cell.rowKey}:${String(cell.rowKey)}\0${cell.columnKey}`;
   const markCellEdited = (cell, previousValue, nextValue) => {
     const key = getCellEditKey(cell);
@@ -2516,75 +3176,113 @@ function Table({
       const visibleRowHeight = fixedHeader ? renderHeight - bodyTop : renderHeight;
       if (rowTop < scroller.scrollTop) scroller.scrollTop = rowTop;
       if (rowBottom > scroller.scrollTop + visibleRowHeight) scroller.scrollTop = rowBottom - visibleRowHeight;
-      if (columns[columnIndex].fixed === void 0 && metric.left < scroller.scrollLeft + fixedWidth) scroller.scrollLeft = Math.max(0, metric.left - fixedWidth);
-      if (columns[columnIndex].fixed === void 0 && metric.left + cellWidth > scroller.scrollLeft + viewport.width - rightFixedWidth) scroller.scrollLeft = metric.left + cellWidth - viewport.width + rightFixedWidth;
+      if (columns[columnIndex].fixed === void 0) {
+        const cellLeft = getScrollableColumnLeft(columnIndex);
+        if (cellLeft < scroller.scrollLeft + fixedWidth) scroller.scrollLeft = Math.max(0, cellLeft - fixedWidth);
+        if (cellLeft + cellWidth > scroller.scrollLeft + viewport.width - rightFixedWidth) scroller.scrollLeft = cellLeft + cellWidth - viewport.width + rightFixedWidth;
+      }
     }
-  }, [beginEdit, bodyTop, columns, editing, renderHeight, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, getRowKey, metrics, rightFixedWidth, rowHeight, rows, selection, setSelection, viewport.width]);
+  }, [beginEdit, bodyTop, columns, editing, renderHeight, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, getRowKey, getScrollableColumnLeft, metrics, rightFixedWidth, rowHeight, rows, selection, setSelection, viewport.width]);
   const editorStyle = useMemo(() => {
     if (!editing) return void 0;
     const metric = metrics[editing.columnIndex];
-    const fixedSide = columns[editing.columnIndex].fixed;
+    const column = columns[editing.columnIndex];
+    if (!metric || !column) return void 0;
+    const fixedSide = column.fixed;
     const span = getCellSpan(editing.rowIndex, editing.columnIndex);
     const cellWidth = getCellDisplayWidth(editing.columnIndex, span?.colSpan ?? 1);
     const cellHeight = rowHeight * (span?.rowSpan ?? 1);
-    const cellLeft = fixedSide === "left" ? metric.left : fixedSide === "right" ? viewport.width - (rightFixedOffsets.get(editing.columnIndex) ?? 0) - metric.width : metric.left - scrollRef.current.left;
+    const cellLeft = fixedSide === "left" ? leftFixedOffsets.get(editing.columnIndex) ?? 0 : fixedSide === "right" ? viewport.width - (rightFixedOffsets.get(editing.columnIndex) ?? 0) - metric.width : getScrollableColumnLeft(editing.columnIndex) - scrollRef.current.left;
+    const cellTop = bodyTop + editing.rowIndex * rowHeight - scrollRef.current.top;
+    const horizontalStart = fixedSide === void 0 ? fixedWidth : 0;
+    const horizontalEnd = fixedSide === void 0 ? viewport.width - rightFixedWidth : viewport.width;
+    const verticalStart = fixedHeader ? bodyTop : 0;
+    const visibleLeft = Math.max(cellLeft, horizontalStart);
+    const visibleRight = Math.min(cellLeft + cellWidth, horizontalEnd, viewport.width);
+    const visibleTop = Math.max(cellTop, verticalStart);
+    const visibleBottom = Math.min(cellTop + cellHeight, renderHeight);
     return {
-      left: (fixedSide ? cellLeft : Math.max(cellLeft, fixedWidth)) + 1,
-      top: Math.max(fixedHeader ? bodyTop : 0, bodyTop + editing.rowIndex * rowHeight - scrollRef.current.top) + 1,
-      width: cellWidth - 2,
-      height: cellHeight - 2
+      left: visibleLeft,
+      top: visibleTop,
+      width: Math.max(0, visibleRight - visibleLeft),
+      height: Math.max(0, visibleBottom - visibleTop)
     };
-  }, [bodyTop, columns, editing, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, metrics, rightFixedOffsets, rowHeight, viewport.width]);
+  }, [bodyTop, columns, editing, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, getScrollableColumnLeft, leftFixedOffsets, metrics, renderHeight, rightFixedOffsets, rightFixedWidth, rowHeight, viewport.width]);
   const handleColumnPointerDown = useCallback2((event) => {
     const rect = event.currentTarget.getBoundingClientRect();
     const localY = event.clientY - rect.top;
     const headerY = fixedHeader ? 0 : -scrollRef.current.top;
     if (localY < headerY || localY >= headerY + headerHeight) return;
-    const resizeIndex = locateResizeHandle(event.clientX);
-    if (resizeIndex >= 0) {
+    const resizeHit = locateHeaderResizeHit(event.clientX, event.clientY);
+    if (resizeHit) {
+      const { cell: resizeCell, edge: resizeEdge } = resizeHit;
       event.preventDefault();
       event.currentTarget.setPointerCapture(event.pointerId);
-      const neighborIndex = findResizeNeighbor(resizeIndex);
-      const startGuideX = getDisplayedColumnLeft(resizeIndex) + metrics[resizeIndex].width;
+      const resizeIndex = resizeCell.endIndex;
+      const resizeIndices = resizeCell.leaf ? [resizeIndex] : Array.from({ length: resizeCell.endIndex - resizeCell.startIndex + 1 }, (_, index) => resizeCell.startIndex + index);
+      const startWidths = resizeIndices.map((index) => metrics[index].width);
+      const startGuideX = getHeaderCellLeft(resizeCell) + (resizeEdge === "right" ? getHeaderCellWidth(resizeCell) : 0);
       columnDragRef.current = {
         type: "resize",
         columnIndex: resizeIndex,
         startX: event.clientX,
-        startWidth: metrics[resizeIndex].width,
-        startGuideX,
-        neighborIndex,
-        startNeighborWidth: neighborIndex >= 0 ? metrics[neighborIndex].width : 0
+        startWidth: startWidths.reduce((total, width2) => total + width2, 0),
+        guideTop: headerRowOffsets[resizeCell.level] ?? 0,
+        resizeEdge,
+        resizeStartIndex: resizeCell.startIndex,
+        resizeEndIndex: resizeCell.endIndex,
+        resizeIndices,
+        startWidths
       };
       suppressClickRef.current = true;
+      setResizeGuideTop(headerRowOffsets[resizeCell.level] ?? 0);
       setResizeGuideX(startGuideX);
       return;
     }
-  }, [findResizeNeighbor, fixedHeader, getDisplayedColumnLeft, headerHeight, locateResizeHandle, metrics]);
+  }, [fixedHeader, getHeaderCellLeft, getHeaderCellWidth, headerHeight, headerRowOffsets, locateHeaderResizeHit, metrics]);
   const handleColumnPointerMove = useCallback2((event) => {
     const drag = columnDragRef.current;
     if (!drag) return;
     const column = columns[drag.columnIndex];
     const minWidth = getMinimumColumnWidth(column, columnDraggable);
-    let delta = Math.round(event.clientX - drag.startX);
-    if (drag.neighborIndex >= 0) {
-      const neighbor = columns[drag.neighborIndex];
-      const minNeighborWidth = getMinimumColumnWidth(neighbor, columnDraggable);
-      delta = Math.max(minWidth - drag.startWidth, Math.min(drag.startNeighborWidth - minNeighborWidth, delta));
-      onColumnResize?.(column.key, drag.startWidth + delta);
-      onColumnResize?.(neighbor.key, drag.startNeighborWidth - delta);
-      setResizeGuideX(drag.startGuideX + delta);
+    const pointerDelta = Math.round(event.clientX - drag.startX);
+    const delta = drag.resizeEdge === "left" ? -pointerDelta : pointerDelta;
+    const setGuideFromWidths = (nextWidths) => {
+      const widthByIndex = new Map(drag.resizeIndices.map((columnIndex, index) => [columnIndex, nextWidths[index]]));
+      const nextColumns = columns.map((column2, index) => widthByIndex.has(index) ? { ...column2, width: widthByIndex.get(index) } : column2);
+      const nextMetrics = buildColumnMetrics(nextColumns, { columnDraggable, viewportWidth: viewport.width });
+      setResizeGuideX(getHeaderCellEdgeFromMetrics(drag.resizeStartIndex, drag.resizeEndIndex, drag.resizeEdge, nextMetrics));
+    };
+    if (drag.resizeIndices.length > 1) {
+      const minWidths = drag.resizeIndices.map((index) => getMinimumColumnWidth(columns[index], columnDraggable));
+      const minTotalWidth = minWidths.reduce((total, width3) => total + width3, 0);
+      const targetTotalWidth = Math.max(minTotalWidth, drag.startWidth + delta);
+      const ratio = drag.startWidth > 0 ? targetTotalWidth / drag.startWidth : 1;
+      const nextWidths = drag.startWidths.map((width3, index) => Math.max(minWidths[index], Math.round(width3 * ratio)));
+      let remainder = targetTotalWidth - nextWidths.reduce((total, width3) => total + width3, 0);
+      for (let index = nextWidths.length - 1; index >= 0 && remainder !== 0; index -= 1) {
+        const next = nextWidths[index] + (remainder > 0 ? 1 : -1);
+        if (next < minWidths[index]) continue;
+        nextWidths[index] = next;
+        remainder += remainder > 0 ? -1 : 1;
+      }
+      drag.resizeIndices.forEach((columnIndex, index) => {
+        resizeColumn(columns[columnIndex].key, nextWidths[index]);
+      });
+      setGuideFromWidths(nextWidths);
       return;
     }
     const width2 = Math.max(minWidth, Math.round(drag.startWidth + delta));
-    onColumnResize?.(column.key, width2);
-    setResizeGuideX(drag.startGuideX + width2 - drag.startWidth);
-  }, [columnDraggable, columns, onColumnResize]);
+    resizeColumn(column.key, width2);
+    setGuideFromWidths([width2]);
+  }, [columnDraggable, columns, getHeaderCellEdgeFromMetrics, resizeColumn, viewport.width]);
   const handleColumnPointerUp = useCallback2((event) => {
     const drag = columnDragRef.current;
     if (!drag) return;
     if (event.currentTarget.hasPointerCapture(event.pointerId)) event.currentTarget.releasePointerCapture(event.pointerId);
     columnDragRef.current = null;
     setResizeGuideX(null);
+    setResizeGuideTop(0);
   }, []);
   const queueSortStateChange = useCallback2((next) => {
     setDisplaySortState(next);
@@ -2597,7 +3295,7 @@ function Table({
   const renderHeaderIcons = (columnIndex, left) => {
     const column = columns[columnIndex];
     if (column.rowSelection || column.rowDragHandle || column.rowNumber) return null;
-    const top = (headerHeight - 14) / 2;
+    const top = headerLeafTop + (headerLeafHeight - 14) / 2;
     const visibleActions = getVisibleHeaderActions(column, metrics[columnIndex].width, columnDraggable, measureHeaderTitleWidth(columnIndex));
     let right = left + metrics[columnIndex].width - (visibleActions.drag ? 18 : 4);
     const icons = [];
@@ -2623,44 +3321,87 @@ function Table({
     }
     return icons;
   };
-  const headerTooltip = (() => {
-    if (!visibleHeaderTooltip) return null;
-    const { columnIndex, action } = visibleHeaderTooltip;
-    const column = columns[columnIndex];
+  const createHeaderTooltip = useCallback2((action, columnIndex, cell) => {
+    const column = cell?.column ?? columns[columnIndex];
     if (!column) return null;
-    const columnRight = getDisplayedColumnLeft(columnIndex) + metrics[columnIndex].width;
-    const visibleActions = getVisibleHeaderActions(column, metrics[columnIndex].width, columnDraggable, measureHeaderTitleWidth(columnIndex));
-    let anchorX = columnRight - (visibleActions.drag ? 18 : 4);
-    let anchorLeft = anchorX;
-    let label;
+    const cellLeft = cell ? getHeaderCellLeft(cell) : getDisplayedColumnLeft(columnIndex);
+    const cellWidth = cell ? getHeaderCellWidth(cell) : metrics[columnIndex]?.width ?? 0;
+    const level = cell?.level ?? headerDepth - 1;
+    const rowTop = (fixedHeader ? 0 : -scrollPosition.top) + (headerRowOffsets[level] ?? 0);
+    const rowHeight2 = headerRowHeights[level] ?? baseHeaderHeight;
+    let anchorX = cellLeft + cellWidth / 2;
+    let anchorLeft = cellLeft;
+    let label = column.title;
     if (action === "title") {
-      const titleWidth = measureHeaderTitleWidth(columnIndex);
-      const actionWidth = (Number(visibleActions.drag) + Number(visibleActions.filter) + Number(visibleActions.sort)) * 18;
-      const contentWidth2 = Math.max(0, metrics[columnIndex].width - actionWidth);
-      const textWidth = Math.min(titleWidth, Math.max(0, contentWidth2 - 20));
-      const columnLeft = getDisplayedColumnLeft(columnIndex);
-      anchorX = column.align === "right" ? columnLeft + contentWidth2 - 10 : column.align === "center" ? columnLeft + metrics[columnIndex].width / 2 + textWidth / 2 : columnLeft + 10 + textWidth;
-      anchorLeft = column.align === "right" ? anchorX - textWidth : column.align === "center" ? columnLeft + metrics[columnIndex].width / 2 - textWidth / 2 : columnLeft + 10;
-      label = column.title;
+      const canvas = canvasRef.current;
+      const context = canvas?.getContext("2d");
+      if (context) context.font = "600 13px Inter, ui-sans-serif, system-ui, sans-serif";
+      const titleWidth = context?.measureText(column.title).width ?? column.title.length * 13;
+      const visibleActions = cell?.leaf || !cell ? getVisibleHeaderActions(column, cellWidth, columnDraggable, titleWidth) : null;
+      const actionWidth = visibleActions ? (Number(visibleActions.drag) + Number(visibleActions.filter) + Number(visibleActions.sort)) * 18 : columnDraggable ? 18 : 0;
+      const contentWidth2 = Math.max(0, cellWidth - actionWidth);
+      const maxTextWidth = Math.max(0, contentWidth2 - 20);
+      const textWidth = Math.min(titleWidth, maxTextWidth);
+      if (column.align === "right") {
+        anchorX = cellLeft + contentWidth2 - 10;
+        anchorLeft = anchorX - textWidth;
+      } else if (column.align === "center") {
+        anchorX = cellLeft + contentWidth2 / 2 + textWidth / 2;
+        anchorLeft = cellLeft + contentWidth2 / 2 - textWidth / 2;
+      } else {
+        anchorLeft = cellLeft + 10;
+        anchorX = anchorLeft + textWidth;
+      }
     } else if (action === "drag") {
-      anchorX = columnRight;
+      anchorX = cellLeft + cellWidth;
       anchorLeft = anchorX;
       label = labels.dragColumn;
     } else if (action === "sort") {
       const direction = displaySortState?.columnKey === column.key ? displaySortState.direction : null;
       label = direction === "asc" ? labels.sortAsc : direction === "desc" ? labels.sortDesc : labels.sortBoth;
-    } else {
-      if (visibleActions.sort) anchorX -= 18;
+      anchorX = cellLeft + cellWidth - 22;
+      anchorLeft = anchorX;
+    } else if (action === "filter") {
       const value = filterValues[column.key];
       label = value ? labels.filterWithValue(value) : labels.filter;
+      anchorX = cellLeft + cellWidth - 40;
+      anchorLeft = anchorX;
     }
     const placement = anchorX + 328 > viewport.width ? "left" : "right";
     return {
+      key: `${action}:${cell ? `cell:${cell.key}:${cell.level}` : `column:${column.key}`}:${Math.round(anchorX)}:${Math.round(rowTop)}`,
+      columnIndex,
+      action,
       left: placement === "right" ? anchorX + 8 : Math.max(8, anchorLeft - 8),
-      top: (fixedHeader ? 0 : -scrollPosition.top) + headerHeight / 2,
+      top: rowTop + rowHeight2 / 2,
       label,
       placement
     };
+  }, [baseHeaderHeight, columnDraggable, columns, displaySortState, filterValues, fixedHeader, getDisplayedColumnLeft, getHeaderCellLeft, getHeaderCellWidth, headerDepth, headerRowHeights, headerRowOffsets, labels, metrics, scrollPosition.top, viewport.width]);
+  const isPointerOnHeaderTitle = useCallback2((clientX, clientY, cell) => {
+    const canvas = canvasRef.current;
+    if (!canvas) return false;
+    const rect = canvas.getBoundingClientRect();
+    const localX = clientX - rect.left;
+    const localY = clientY - rect.top;
+    const column = cell.column;
+    const cellLeft = getHeaderCellLeft(cell);
+    const cellWidth = getHeaderCellWidth(cell);
+    const rowTop = (fixedHeader ? 0 : -scrollRef.current.top) + (headerRowOffsets[cell.level] ?? 0);
+    const context = canvas.getContext("2d");
+    if (context) context.font = "600 13px Inter, ui-sans-serif, system-ui, sans-serif";
+    const titleWidth = context?.measureText(column.title).width ?? column.title.length * 13;
+    const visibleActions = cell.leaf ? getVisibleHeaderActions(column, cellWidth, columnDraggable, titleWidth) : null;
+    const actionWidth = visibleActions ? (Number(visibleActions.drag) + Number(visibleActions.filter) + Number(visibleActions.sort)) * 18 : columnDraggable ? 18 : 0;
+    const contentWidth2 = Math.max(0, cellWidth - actionWidth);
+    const textWidth = Math.min(titleWidth, Math.max(0, contentWidth2 - 20));
+    const textLeft = column.align === "right" ? cellLeft + contentWidth2 - 10 - textWidth : column.align === "center" ? cellLeft + contentWidth2 / 2 - textWidth / 2 : cellLeft + 10;
+    const textTop = rowTop + 8;
+    return localX >= textLeft - 4 && localX <= textLeft + textWidth + 4 && localY >= textTop - 2 && localY <= textTop + 18;
+  }, [columnDraggable, fixedHeader, getHeaderCellLeft, getHeaderCellWidth, headerRowOffsets]);
+  const headerTooltip = (() => {
+    if (!visibleHeaderTooltip) return null;
+    return visibleHeaderTooltip;
   })();
   const getRangeBounds = () => selectionRange ? {
     rowStart: Math.min(selectionRange.anchor.rowIndex, selectionRange.focus.rowIndex),
@@ -2719,7 +3460,7 @@ function Table({
     }, 1800);
   };
   const showHeaderTooltipAfterDelay = (next) => {
-    const nextKey = next ? `${next.columnIndex}:${next.action}` : "";
+    const nextKey = next ? next.key : "";
     if (nextKey && pendingHeaderTooltipKeyRef.current === nextKey) return;
     pendingHeaderTooltipKeyRef.current = nextKey;
     if (headerTooltipTimerRef.current !== null) clearTimeout(headerTooltipTimerRef.current);
@@ -2967,12 +3708,14 @@ function Table({
   const renderHeaderTitle = (columnIndex, left) => {
     const column = columns[columnIndex];
     const currentScrollTop = scrollRef.current.top;
+    const headerTop = fixedHeader ? 0 : -currentScrollTop;
+    const leafTop = headerTop + headerLeafTop;
     if (column.rowNumber) {
       return /* @__PURE__ */ jsx7(
         "div",
         {
           className: "rvg-header-title",
-          style: { left, top: fixedHeader ? 0 : -currentScrollTop, width: metrics[columnIndex].width, height: headerHeight, justifyContent: "center", padding: 0, textAlign: "center" },
+          style: { left, top: headerTop, width: metrics[columnIndex].width, height: headerHeight, justifyContent: "center", padding: 0, textAlign: "center" },
           children: /* @__PURE__ */ jsx7("span", { children: column.title })
         },
         column.key
@@ -2986,7 +3729,7 @@ function Table({
         "div",
         {
           className: "rvg-header-selection-icon",
-          style: { left, top: fixedHeader ? 0 : -currentScrollTop, width: metrics[columnIndex].width, height: headerHeight },
+          style: { left, top: headerTop, width: metrics[columnIndex].width, height: headerHeight },
           children: /* @__PURE__ */ jsx7(SelectionIcon, { checked: allSelected, indeterminate })
         },
         column.key
@@ -2999,11 +3742,13 @@ function Table({
         "div",
         {
           className: "rvg-header-title is-custom",
+          "data-level": headerDepth - 1,
+          "data-measure-key": column.key,
           style: {
             left,
-            top: fixedHeader ? 0 : -currentScrollTop,
+            top: leafTop,
             width: Math.max(0, metrics[columnIndex].width - actionWidth),
-            height: headerHeight,
+            height: headerLeafHeight,
             justifyContent: column.align === "right" ? "flex-end" : column.align === "center" ? "center" : "flex-start",
             textAlign: column.align === "right" ? "right" : column.align === "center" ? "center" : "left"
           },
@@ -3011,8 +3756,10 @@ function Table({
             "span",
             {
               ref: (node) => {
-                if (node) customHeaderContentRefs.current.set(column.key, node);
-                else customHeaderContentRefs.current.delete(column.key);
+                if (node) {
+                  customHeaderContentRefs.current.set(column.key, node);
+                  requestAnimationFrame(measureCustomHeaderHeight);
+                } else customHeaderContentRefs.current.delete(column.key);
               },
               children: column.renderHeader(column)
             }
@@ -3023,6 +3770,61 @@ function Table({
     }
     return null;
   };
+  const renderGroupedHeaderCell = (cell) => {
+    const startMetric = metrics[cell.startIndex];
+    const endMetric = metrics[cell.endIndex];
+    if (!startMetric || !endMetric) return null;
+    const column = cell.column;
+    const fixedSide = columns[cell.startIndex]?.fixed;
+    const currentScrollTop = scrollRef.current.top;
+    const rowHeightForLevel = headerRowHeights[cell.level] ?? baseHeaderHeight;
+    const headerTop = (fixedHeader ? 0 : -currentScrollTop) + (headerRowOffsets[cell.level] ?? 0);
+    const left = fixedSide === "left" ? leftFixedOffsets.get(cell.startIndex) ?? 0 : fixedSide === "right" ? viewport.width - (rightFixedOffsets.get(cell.startIndex) ?? 0) - startMetric.width : getScrollableColumnLeft(cell.startIndex);
+    const width2 = cell.leaf ? startMetric.width : getCellDisplayWidth(cell.startIndex, cell.endIndex - cell.startIndex + 1);
+    const visibleActions = cell.leaf ? getVisibleHeaderActions(column, startMetric.width, columnDraggable, measureHeaderTitleWidth(cell.startIndex)) : null;
+    const actionWidth = visibleActions ? (Number(visibleActions.drag) + Number(visibleActions.filter) + Number(visibleActions.sort)) * 18 : columnDraggable && !cell.leaf ? 18 : 0;
+    return /* @__PURE__ */ jsxs7(
+      "div",
+      {
+        className: `rvg-header-title rvg-header-group${column.renderHeader ? " is-custom" : ""}${cell.leaf ? " is-leaf" : ""}`,
+        "data-level": cell.level,
+        "data-measure-key": `group:${cell.key}:${cell.level}`,
+        style: {
+          left,
+          top: headerTop,
+          width: width2,
+          height: rowHeightForLevel,
+          paddingRight: cell.leaf ? actionWidth + 10 : 10,
+          justifyContent: column.align === "right" ? "flex-end" : column.align === "center" ? "center" : "flex-start",
+          textAlign: column.align === "right" ? "right" : column.align === "center" ? "center" : "left"
+        },
+        children: [
+          /* @__PURE__ */ jsx7(
+            "span",
+            {
+              ref: (node) => {
+                if (!column.renderHeader) return;
+                const key = `group:${cell.key}:${cell.level}`;
+                if (node) {
+                  customHeaderContentRefs.current.set(key, node);
+                  requestAnimationFrame(measureCustomHeaderHeight);
+                } else customHeaderContentRefs.current.delete(key);
+              },
+              children: column.renderHeader ? column.renderHeader(column) : column.title
+            }
+          ),
+          !cell.leaf && columnDraggable && /* @__PURE__ */ jsx7(
+            HeaderDragIcon,
+            {
+              className: `rvg-header-icon rvg-header-drag-icon${hoveredHeaderAction?.columnIndex === cell.startIndex && hoveredHeaderAction.action === "drag" ? " is-hovered" : ""}`,
+              style: { left: width2 - 16, top: (rowHeightForLevel - 14) / 2 }
+            }
+          )
+        ]
+      },
+      `group:${cell.key}:${cell.level}`
+    );
+  };
   const rangeHandlePosition = (() => {
     if (!rangeSelection) return null;
     const bounds = getRangeBounds();
@@ -3054,9 +3856,9 @@ function Table({
     const verticalStart = fixedHeader ? bodyTop : 0;
     if (rawRight <= horizontalStart || rawLeft >= horizontalEnd || rawBottom <= verticalStart || rawTop >= renderHeight) return null;
     const borderWidth = 2;
-    const left = Math.round(Math.max(rawLeft - borderWidth, horizontalStart - 1));
+    const left = Math.round(Math.max(rawLeft - borderWidth, horizontalStart));
     const right = Math.round(Math.min(rawRight + 1, horizontalEnd, viewport.width));
-    const top = Math.round(Math.max(rawTop - borderWidth, verticalStart - 1));
+    const top = Math.round(Math.max(rawTop - borderWidth, verticalStart));
     const bottom = Math.round(Math.min(rawBottom + 1, renderHeight));
     return {
       left,
@@ -3065,6 +3867,19 @@ function Table({
       height: Math.max(0, bottom - top)
     };
   })();
+  const selectionEdgeIndicator = getSelectionEdgeIndicator(scrollPosition.left, scrollPosition.top);
+  const selectionEdgeStyle = selectionEdgeIndicator ? {
+    ...selectionEdgeIndicator.style,
+    ...selectionEdgeIndicator.corner ? {
+      "--rvg-corner-width": `${selectionEdgeIndicator.corner.width}px`,
+      "--rvg-corner-height": `${selectionEdgeIndicator.corner.height}px`,
+      "--rvg-corner-hover-width-extension": "4px",
+      "--rvg-corner-hover-height-extension": "4px"
+    } : null
+  } : void 0;
+  useLayoutEffect2(() => {
+    syncSelectionEdgeTarget(scrollPosition.left, scrollPosition.top);
+  }, [scrollPosition.left, scrollPosition.top, syncSelectionEdgeTarget]);
   const handleContextMenu = (event) => {
     event.preventDefault();
     event.stopPropagation();
@@ -3214,15 +4029,19 @@ function Table({
             const headerY = fixedHeader ? 0 : -scrollRef.current.top;
             const columnIndex = locateColumn(event.clientX);
             const inHeader = localY >= headerY && localY < headerY + headerHeight;
-            const hoveredAction = inHeader ? locateHeaderAction(event.clientX, columnIndex) : null;
-            const hoveredDragHandle = inHeader && locateHeaderDragHandle(event.clientX, columnIndex);
-            const hoveredTitle = inHeader && !hoveredAction && !hoveredDragHandle && columnIndex >= 0 && Boolean(columns[columnIndex]?.title) && (tooltipConfig.header || isHeaderTitleTruncated(columnIndex));
-            const nextHover = hoveredAction ? { columnIndex, action: hoveredAction } : hoveredDragHandle ? { columnIndex, action: "drag" } : hoveredTitle ? { columnIndex, action: "title" } : null;
+            const inLeafHeader = inHeader && localY >= headerY + headerLeafTop;
+            const hoveredHeaderCell = inHeader ? locateHeaderCell(event.clientX, event.clientY) : null;
+            const hoveredAction = inLeafHeader ? locateHeaderAction(event.clientX, columnIndex) : null;
+            const hoveredDragHandle = Boolean(hoveredHeaderCell && locateHeaderCellDragHandle(event.clientX, hoveredHeaderCell));
+            const hoveredDragColumnIndex = hoveredHeaderCell?.startIndex ?? columnIndex;
+            const hoveredTitle = inHeader && !hoveredAction && !hoveredDragHandle && hoveredHeaderCell && Boolean(hoveredHeaderCell.column.title) && isPointerOnHeaderTitle(event.clientX, event.clientY, hoveredHeaderCell) && (tooltipConfig.header || hoveredHeaderCell.leaf && isHeaderTitleTruncated(hoveredHeaderCell.startIndex));
+            const nextHover = hoveredAction ? { columnIndex, action: hoveredAction } : hoveredDragHandle ? { columnIndex: hoveredDragColumnIndex, action: "drag" } : hoveredTitle ? { columnIndex: hoveredHeaderCell.startIndex, action: "title" } : null;
+            const nextTooltip = hoveredAction && hoveredHeaderCell ? createHeaderTooltip(hoveredAction, columnIndex, hoveredHeaderCell) : hoveredDragHandle && hoveredHeaderCell ? createHeaderTooltip("drag", hoveredDragColumnIndex, hoveredHeaderCell) : hoveredTitle && hoveredHeaderCell ? createHeaderTooltip("title", hoveredHeaderCell.startIndex, hoveredHeaderCell) : null;
             const previousHover = hoveredHeaderActionRef.current;
             if (previousHover?.columnIndex !== nextHover?.columnIndex || previousHover?.action !== nextHover?.action) {
               hoveredHeaderActionRef.current = nextHover;
               setHoveredHeaderAction(nextHover);
-              showHeaderTooltipAfterDelay(nextHover);
+              showHeaderTooltipAfterDelay(nextTooltip);
               scheduleDraw();
             }
             if (inHeader) {
@@ -3246,8 +4065,8 @@ function Table({
                 if (annotation?.content.trim()) {
                   const cellLeft = getDisplayedColumnLeft(cell.columnIndex);
                   const cellTop = bodyTop + cell.rowIndex * rowHeight - scrollRef.current.top;
-                  const nextTooltip = { rowIndex: cell.rowIndex, columnIndex: cell.columnIndex, left: cellLeft + metrics[cell.columnIndex].width + 6, top: cellTop + rowHeight / 2, label: annotation.content, color: annotation.color, annotation: true };
-                  showCellTooltip(nextTooltip);
+                  const nextTooltip2 = { rowIndex: cell.rowIndex, columnIndex: cell.columnIndex, left: cellLeft + metrics[cell.columnIndex].width + 6, top: cellTop + rowHeight / 2, label: annotation.content, color: annotation.color, annotation: true };
+                  showCellTooltip(nextTooltip2);
                 } else {
                   const label = getCellLabel(cell.rowIndex, cell.columnIndex);
                   const context = event.currentTarget.getContext("2d");
@@ -3274,7 +4093,7 @@ function Table({
                       showCellTooltipAfterDelay(null);
                     } else {
                       const placement = textRight + 330 > viewport.width ? "left" : "right";
-                      const nextTooltip = {
+                      const nextTooltip2 = {
                         rowIndex: cell.rowIndex,
                         columnIndex: cell.columnIndex,
                         left: placement === "right" ? textRight + 16 : Math.max(8, textLeft - 16),
@@ -3282,13 +4101,13 @@ function Table({
                         label,
                         placement
                       };
-                      showCellTooltipAfterDelay(nextTooltip);
+                      showCellTooltipAfterDelay(nextTooltip2);
                     }
                   }
                 }
               }
             }
-            const cursor = inHeader && locateResizeHandle(event.clientX) >= 0 ? "col-resize" : hoveredAction ? "pointer" : hoveredDragHandle ? "move" : columnIndex >= 0 && columns[columnIndex].rowSelection ? "pointer" : !inHeader && rowDraggable && columnIndex >= 0 && columns[columnIndex].rowDragHandle ? "move" : "default";
+            const cursor = inHeader && locateHeaderResizeCell(event.clientX, event.clientY) ? "col-resize" : hoveredAction ? "pointer" : hoveredDragHandle ? "move" : columnIndex >= 0 && columns[columnIndex].rowSelection ? "pointer" : !inHeader && rowDraggable && columnIndex >= 0 && columns[columnIndex].rowDragHandle ? "move" : "default";
             if (event.currentTarget.style.cursor !== cursor) event.currentTarget.style.cursor = cursor;
           },
           onMouseLeave: (event) => {
@@ -3331,6 +4150,7 @@ function Table({
             const headerY = fixedHeader ? 0 : -scrollRef.current.top;
             if (localY >= headerY && localY < headerY + headerHeight) {
               clickedCellRef.current = null;
+              if (localY < headerY + headerLeafTop) return;
               const columnIndex = locateColumn(event.clientX);
               const action = locateHeaderAction(event.clientX, columnIndex);
               if (action === "sort") {
@@ -3392,21 +4212,30 @@ function Table({
             className: "rvg-text-scroll-content",
             style: { left: -fixedWidth, width: contentWidth, transform: `translateX(${-currentScroll.left}px)` },
             children: [
-              columns.map((column, columnIndex) => column.fixed ? null : columnIndex >= domRange.columnStart && columnIndex < domRange.columnEnd ? /* @__PURE__ */ jsx7("span", { children: renderHeaderTitle(columnIndex, metrics[columnIndex].left) }, column.key) : null),
+              columns.map((column, columnIndex) => column.fixed || columnIndex < utilityColumnCount || headerDepth > 1 ? null : columnIndex >= domRange.columnStart && columnIndex < domRange.columnEnd ? /* @__PURE__ */ jsx7("span", { children: renderHeaderTitle(columnIndex, getScrollableColumnLeft(columnIndex)) }, column.key) : null),
+              headerCells.map((cell) => {
+                if (columns[cell.startIndex]?.fixed) return null;
+                if (cell.endIndex < domRange.columnStart || cell.startIndex >= domRange.columnEnd) return null;
+                return renderGroupedHeaderCell(cell);
+              }),
               /* @__PURE__ */ jsx7("div", { className: "rvg-body-text-clip", style: { top: fixedHeader ? bodyTop : 0, bottom: 0 }, children: Array.from({ length: domRange.rowEnd - domRange.rowStart }, (_, offset) => domRange.rowStart + offset).flatMap((rowIndex) => columns.map((column, columnIndex) => {
                 if (column.fixed || columnIndex < domRange.columnStart || columnIndex >= domRange.columnEnd) return null;
-                return renderCellText(rowIndex, columnIndex, metrics[columnIndex].left);
+                return renderCellText(rowIndex, columnIndex, getScrollableColumnLeft(columnIndex));
               })) })
             ]
           }
         ) }),
         /* @__PURE__ */ jsx7("div", { className: "rvg-body-text-clip", style: { top: fixedHeader ? bodyTop : 0, bottom: 0 }, children: Array.from({ length: domRange.rowEnd - domRange.rowStart }, (_, offset) => domRange.rowStart + offset).flatMap((rowIndex) => columns.map((column, columnIndex) => {
           if (!column.fixed) return null;
-          const left = column.fixed === "left" ? metrics[columnIndex].left : viewport.width - (rightFixedOffsets.get(columnIndex) ?? 0) - metrics[columnIndex].width;
+          const left = column.fixed === "left" ? leftFixedOffsets.get(columnIndex) ?? 0 : viewport.width - (rightFixedOffsets.get(columnIndex) ?? 0) - metrics[columnIndex].width;
           return renderCellText(rowIndex, columnIndex, left);
         })) }),
-        columns.map((column, columnIndex) => column.fixed === "left" ? renderHeaderTitle(columnIndex, metrics[columnIndex].left) : null),
-        columns.map((column, columnIndex) => column.fixed === "right" ? renderHeaderTitle(columnIndex, viewport.width - (rightFixedOffsets.get(columnIndex) ?? 0) - metrics[columnIndex].width) : null)
+        columns.map((column, columnIndex) => columnIndex < utilityColumnCount || headerDepth === 1 && (column.fixed === "left" || column.fixed === "right") ? renderHeaderTitle(columnIndex, column.fixed === "right" ? viewport.width - (rightFixedOffsets.get(columnIndex) ?? 0) - metrics[columnIndex].width : column.fixed === "left" ? leftFixedOffsets.get(columnIndex) ?? 0 : getScrollableColumnLeft(columnIndex)) : null),
+        headerCells.map((cell) => columns[cell.startIndex]?.fixed ? renderGroupedHeaderCell(cell) : null),
+        fixedWidth > 0 && currentScroll.left > 0 && /* @__PURE__ */ jsx7("div", { className: "rvg-text-fixed-shadow is-left", style: { left: fixedWidth } }),
+        rightFixedWidth > 0 && currentScroll.left < contentWidth - viewport.width && /* @__PURE__ */ jsx7("div", { className: "rvg-text-fixed-shadow is-right", style: { right: rightFixedWidth } }),
+        hasVerticalBorders && fixedWidth > 0 && /* @__PURE__ */ jsx7("div", { className: "rvg-text-fixed-border is-left", style: { left: fixedWidth - 1 } }),
+        hasVerticalBorders && rightFixedWidth > 0 && /* @__PURE__ */ jsx7("div", { className: "rvg-text-fixed-border is-right", style: { right: rightFixedWidth } })
       ] }),
       /* @__PURE__ */ jsx7("div", { className: "rvg-spacer", style: { width: contentWidth, height: contentHeight + bodyTop, marginTop: -renderHeight } })
     ] }),
@@ -3414,18 +4243,18 @@ function Table({
       "div",
       {
         className: `rvg-summary-row is-${summaryPosition}${hasVerticalBorders ? "" : " is-vertical-borderless"}`,
-        style: { height: rowHeight, top: summaryPosition === "top" ? headerHeight : void 0 },
+        style: { height: rowHeight, top: summaryPosition === "top" ? fixedHeader ? headerHeight : headerHeight - currentScroll.top : void 0 },
         children: [
           /* @__PURE__ */ jsx7("div", { className: "rvg-summary-scroll-clip", style: { left: fixedWidth, right: rightFixedWidth }, children: /* @__PURE__ */ jsx7(
             "div",
             {
               className: "rvg-summary-scroll-content",
               style: { left: -fixedWidth, width: contentWidth, transform: `translateX(${-currentScroll.left}px)` },
-              children: columns.map((column, columnIndex) => column.fixed ? null : renderSummaryCell(columnIndex, metrics[columnIndex].left))
+              children: columns.map((column, columnIndex) => column.fixed ? null : renderSummaryCell(columnIndex, getScrollableColumnLeft(columnIndex)))
             }
           ) }),
           /* @__PURE__ */ jsxs7("div", { className: "rvg-summary-fixed-layer", children: [
-            columns.map((column, columnIndex) => column.fixed === "left" ? renderSummaryCell(columnIndex, metrics[columnIndex].left) : null),
+            columns.map((column, columnIndex) => column.fixed === "left" ? renderSummaryCell(columnIndex, leftFixedOffsets.get(columnIndex) ?? 0) : null),
             columns.map((column, columnIndex) => column.fixed === "right" ? renderSummaryCell(columnIndex, viewport.width - (rightFixedOffsets.get(columnIndex) ?? 0) - metrics[columnIndex].width) : null)
           ] }),
           fixedWidth > 0 && currentScroll.left > 0 && /* @__PURE__ */ jsx7("div", { className: "rvg-summary-fixed-shadow is-left", style: { left: fixedWidth } }),
@@ -3442,11 +4271,11 @@ function Table({
           ref: scrollingHeaderIconsRef,
           className: "rvg-header-icon-layer rvg-header-icon-layer-scroll",
           style: { left: -fixedWidth, width: contentWidth, transform: `translateX(${-scrollRef.current.left}px)` },
-          children: columns.map((column, index) => column.fixed ? null : /* @__PURE__ */ jsx7("span", { children: renderHeaderIcons(index, metrics[index].left) }, column.key))
+          children: columns.map((column, index) => column.fixed ? null : /* @__PURE__ */ jsx7("span", { children: renderHeaderIcons(index, getScrollableColumnLeft(index)) }, column.key))
         }
       ) }),
       /* @__PURE__ */ jsxs7("div", { className: "rvg-header-icon-layer", children: [
-        columns.map((column, index) => column.fixed === "left" ? /* @__PURE__ */ jsx7("span", { children: renderHeaderIcons(index, metrics[index].left) }, column.key) : null),
+        columns.map((column, index) => column.fixed === "left" ? /* @__PURE__ */ jsx7("span", { children: renderHeaderIcons(index, leftFixedOffsets.get(index) ?? 0) }, column.key) : null),
         columns.map((column, index) => column.fixed === "right" ? /* @__PURE__ */ jsx7("span", { children: renderHeaderIcons(index, viewport.width - (rightFixedOffsets.get(index) ?? 0) - metrics[index].width) }, column.key) : null)
       ] })
     ] }),
@@ -3498,6 +4327,27 @@ function Table({
       }
     ),
     selectionOutlineStyle && /* @__PURE__ */ jsx7("div", { ref: selectionFocusRef, className: "rvg-selection-focus", style: selectionOutlineStyle, "aria-hidden": "true" }),
+    selectionEdgeIndicator && selection && /* @__PURE__ */ jsx7(
+      "button",
+      {
+        ref: selectionEdgeTargetRef,
+        type: "button",
+        className: `rvg-selection-edge-target is-${selectionEdgeIndicator.orientation} is-${selectionEdgeIndicator.side}${selectionEdgeIndicator.viewportEdge ? ` is-viewport-${selectionEdgeIndicator.viewportEdge}` : ""}`,
+        style: selectionEdgeStyle,
+        "aria-label": labels.revealSelectedCell,
+        title: labels.revealSelectedCell,
+        onPointerDown: (event) => {
+          event.preventDefault();
+          event.stopPropagation();
+        },
+        onClick: (event) => {
+          event.stopPropagation();
+          scrollerRef.current?.focus({ preventScroll: true });
+          revealCell(selection);
+        },
+        children: /* @__PURE__ */ jsx7("span", { className: "rvg-selection-edge-halo", "aria-hidden": "true", children: /* @__PURE__ */ jsx7("svg", { viewBox: "0 0 100 100", preserveAspectRatio: "none", children: /* @__PURE__ */ jsx7("path", { d: "M 0 100 L 0 0 L 100 0" }) }) })
+      }
+    ),
     contextMenu && /* @__PURE__ */ jsx7("div", { ref: contextMenuRef, className: "rvg-context-menu", role: "menu", style: { left: contextMenu.left, top: contextMenu.top }, children: contextMenu.type === "header" ? (() => {
       const column = columns[contextMenu.columnIndex];
       const headerContext = { column, columnIndex: contextMenu.columnIndex };
@@ -3723,12 +4573,40 @@ function Table({
       ] })
     ] }) }),
     toast && /* @__PURE__ */ jsx7("div", { className: `rvg-toast is-${toast.type}`, role: "status", children: toast.message }),
+    /* @__PURE__ */ jsx7(
+      "div",
+      {
+        ref: verticalScrollbarRef,
+        className: "rvg-vertical-scrollbar",
+        onPointerEnter: () => keepCustomScrollbarVisible("vertical"),
+        onPointerLeave: () => releaseCustomScrollbarVisible("vertical"),
+        onPointerDown: handleVerticalScrollbarPointerDown,
+        onPointerMove: handleVerticalScrollbarPointerMove,
+        onPointerUp: handleVerticalScrollbarPointerUp,
+        onPointerCancel: handleVerticalScrollbarPointerUp,
+        children: /* @__PURE__ */ jsx7("div", { ref: verticalScrollbarThumbRef, className: "rvg-vertical-scrollbar-thumb" })
+      }
+    ),
+    /* @__PURE__ */ jsx7(
+      "div",
+      {
+        ref: horizontalScrollbarRef,
+        className: "rvg-horizontal-scrollbar",
+        onPointerEnter: () => keepCustomScrollbarVisible("horizontal"),
+        onPointerLeave: () => releaseCustomScrollbarVisible("horizontal"),
+        onPointerDown: handleHorizontalScrollbarPointerDown,
+        onPointerMove: handleHorizontalScrollbarPointerMove,
+        onPointerUp: handleHorizontalScrollbarPointerUp,
+        onPointerCancel: handleHorizontalScrollbarPointerUp,
+        children: /* @__PURE__ */ jsx7("div", { ref: horizontalScrollbarThumbRef, className: "rvg-horizontal-scrollbar-thumb" })
+      }
+    ),
     /* @__PURE__ */ jsx7("div", { ref: dragGuideRef, className: "rvg-column-guide" }),
     resizeGuideX !== null && /* @__PURE__ */ jsx7(
       "div",
       {
         className: "rvg-column-guide is-resizing",
-        style: { display: "block", transform: `translateX(${Math.round(resizeGuideX)}px)` }
+        style: { display: "block", top: resizeGuideTop, transform: `translateX(${Math.round(resizeGuideX)}px)` }
       }
     ),
     /* @__PURE__ */ jsx7("div", { ref: rowDragGuideRef, className: "rvg-row-guide" }),
@@ -3794,8 +4672,8 @@ function Table({
           column.key
         );
       }) }, rowIndex)),
-      fixedWidth > 0 && /* @__PURE__ */ jsx7("div", { className: "rvg-loading-fixed-shadow is-left", style: { left: fixedWidth } }),
-      rightFixedWidth > 0 && /* @__PURE__ */ jsx7("div", { className: "rvg-loading-fixed-shadow is-right", style: { right: rightFixedWidth } })
+      fixedWidth > 0 && currentScroll.left > 0 && /* @__PURE__ */ jsx7("div", { className: "rvg-loading-fixed-shadow is-left", style: { left: fixedWidth } }),
+      rightFixedWidth > 0 && currentScroll.left < contentWidth - viewport.width && /* @__PURE__ */ jsx7("div", { className: "rvg-loading-fixed-shadow is-right", style: { right: rightFixedWidth } })
     ] }),
     loading && !hasCustomLoading && hasCompletedLoadRef.current && /* @__PURE__ */ jsx7("div", { className: "rvg-refresh-loading", "aria-label": labels.refreshing, children: /* @__PURE__ */ jsx7(LoadingSpinnerIcon, {}) })
   ] });