handsontable 18.0.0 → 18.1.0-rc7

package/helpers/dom/cellCoords.js

@@ -31,7 +31,7 @@ const _errors = require("../errors");
             return column;
         }
         accumulatedX += width;
-        const { colspan } = hotInstance.getCellMeta(row, column);
+        const { colspan } = hotInstance.getCellMetaTransient(row, column);
         if (colspan !== undefined && colspan > 1) {
             column += colspan - 1;
         }
@@ -59,13 +59,117 @@ const _errors = require("../errors");
             return row;
         }
         accumulatedY += height;
-        const { rowspan } = hotInstance.getCellMeta(row, column);
+        const { rowspan } = hotInstance.getCellMetaTransient(row, column);
         if (rowspan !== undefined && rowspan > 1) {
             row += rowspan - 1;
         }
     }
     return null;
 }
+/**
+ * Finds a column suitable for mapping a Y coordinate to a row: the first column in the range
+ * whose cells across the scanned rows each occupy their own single row. `findRowAtY` walks one
+ * column's cell heights and skips a merged cell's spanned rows, so it is distorted by a cell
+ * that spans multiple rows — a vertical-merge anchor or any of its slaves. Such a column is
+ * detected two ways: `rowspan > 1` on the anchor's meta, and element identity, since every row
+ * inside a vertical merge resolves to the same rendered cell. A purely horizontal merge resolves
+ * to a distinct, single-row master cell per row, so its columns stay valid. A merge in one column
+ * must not distort the row lookup used for other columns (DEV-2115).
+ *
+ * The scanned row range must match the range the returned column will be walked over (the frozen
+ * overlays and the scrollable body are resolved separately), so a merge confined to frozen rows
+ * cannot leak into the body lookup or vice versa.
+ *
+ * @param {Handsontable} hotInstance The Handsontable instance.
+ * @param {number} startColumn First column to consider.
+ * @param {number} endColumn Last column to consider (inclusive).
+ * @param {number} startRow First row of the scanned range.
+ * @param {number} endRow Last row of the scanned range (inclusive).
+ * @returns {number} A column index free of vertical-merge distortion, or `startColumn` if none qualifies.
+ */ function findRowReferenceColumn(hotInstance, startColumn, endColumn, startRow, endRow) {
+    for(let column = startColumn; column <= endColumn; column++){
+        let spansMultipleRows = false;
+        let hasRenderableCell = false;
+        let previousCell = null;
+        for(let row = startRow; row <= endRow; row++){
+            const cell = hotInstance.getCell(row, column, true);
+            const { rowspan } = hotInstance.getCellMetaTransient(row, column);
+            // A vertically merged cell reports `rowspan > 1` on its anchor and resolves to the same
+            // rendered element for every row it covers; either signal marks the column as distorting.
+            if (rowspan !== undefined && rowspan > 1 || cell !== null && cell === previousCell) {
+                spansMultipleRows = true;
+                break;
+            }
+            if (cell !== null) {
+                previousCell = cell;
+                hasRenderableCell = true;
+            }
+        }
+        // A hidden column (e.g. `hiddenColumns`) renders no cells, so `findRowAtY` cannot measure
+        // against it. Require at least one renderable cell so a hidden column between the merged
+        // column and a usable one is skipped rather than picked as the reference.
+        if (!spansMultipleRows && hasRenderableCell) {
+            return column;
+        }
+    }
+    // Best-effort fallback: every column in the scanned range is vertically merged (e.g. a grouped
+    // report grid whose visible columns all merge across the same band). No column is free of the
+    // distortion, so `findRowAtY` will still collapse the band onto its anchor — `startColumn` is
+    // simply the least-surprising choice. This is a known narrow case of DEV-2115, not a bug here.
+    return startColumn;
+}
+/**
+ * Finds a row suitable for mapping an X coordinate to a column: the first row in the range
+ * whose cells across the scanned columns each occupy their own single column. `findColumnAtX`
+ * walks one row's cell widths and skips a merged cell's spanned columns, so it is distorted by a
+ * cell that spans multiple columns - a horizontal-merge anchor or any of its slaves. Such a row
+ * is detected two ways: `colspan > 1` on the anchor's meta, and element identity, since every
+ * column inside a horizontal merge resolves to the same rendered cell. A purely vertical merge
+ * resolves to a distinct, single-column master cell per column, so its rows stay valid. A merge
+ * in one row must not distort the column lookup used for other rows (DEV-2124).
+ *
+ * The scanned column range must match the range the returned row will be walked over (the frozen
+ * overlays and the scrollable body are resolved separately), so a merge confined to frozen
+ * columns cannot leak into the body lookup or vice versa.
+ *
+ * @param {Handsontable} hotInstance The Handsontable instance.
+ * @param {number} startRow First row to consider.
+ * @param {number} endRow Last row to consider (inclusive).
+ * @param {number} startColumn First column of the scanned range.
+ * @param {number} endColumn Last column of the scanned range (inclusive).
+ * @returns {number} A row index free of horizontal-merge distortion, or `startRow` if none qualifies.
+ */ function findColumnReferenceRow(hotInstance, startRow, endRow, startColumn, endColumn) {
+    for(let row = startRow; row <= endRow; row++){
+        let spansMultipleColumns = false;
+        let hasRenderableCell = false;
+        let previousCell = null;
+        for(let column = startColumn; column <= endColumn; column++){
+            const cell = hotInstance.getCell(row, column, true);
+            const { colspan } = hotInstance.getCellMetaTransient(row, column);
+            // A horizontally merged cell reports `colspan > 1` on its anchor and resolves to the same
+            // rendered element for every column it covers; either signal marks the row as distorting.
+            if (colspan !== undefined && colspan > 1 || cell !== null && cell === previousCell) {
+                spansMultipleColumns = true;
+                break;
+            }
+            if (cell !== null) {
+                previousCell = cell;
+                hasRenderableCell = true;
+            }
+        }
+        // A hidden row (e.g. `hiddenRows`) renders no cells, so `findColumnAtX` cannot measure
+        // against it. Require at least one renderable cell so a hidden row between the merged
+        // row and a usable one is skipped rather than picked as the reference.
+        if (!spansMultipleColumns && hasRenderableCell) {
+            return row;
+        }
+    }
+    // Best-effort fallback: every row in the scanned range is horizontally merged (e.g. a banded
+    // report grid whose visible rows all merge across the same columns). No row is free of the
+    // distortion, so `findColumnAtX` will still collapse the band onto its anchor - `startRow` is
+    // simply the least-surprising choice. This is a known narrow case of DEV-2124, not a bug here.
+    return startRow;
+}
 function getCellCoordsFromMousePosition(hotInstance, mouseX, mouseY) {
     const { view, columnIndexMapper, rowIndexMapper } = hotInstance;
     const isRtl = hotInstance.isRtl();
@@ -101,6 +205,20 @@ function getCellCoordsFromMousePosition(hotInstance, mouseX, mouseY) {
     const tableViewportBottom = view.isVerticallyScrollableByWindow() ? rootWindow.innerHeight : tableOffset.top + view.getViewportHeight() + columnHeaderHeight;
     const clampedX = (0, _number.clamp)(mouseX, tableViewportLeft, tableViewportRight);
     const clampedY = (0, _number.clamp)(mouseY, tableViewportTop, tableViewportBottom);
+    // Resolve the column against a row that has no horizontal merge across the columns being
+    // walked. `findColumnAtX` skips a merged cell's spanned columns, so measuring against a
+    // horizontally merged row collapses every X inside the band onto the merge anchor - and when
+    // the anchor is scrolled out of view the band's full width is counted once per slave column.
+    // Neither a fixed row nor the pointer's row is universally safe (a merge can live in either),
+    // so each column-scan branch picks the first row free of horizontal merges within its own
+    // column range (DEV-2124).
+    const columnReferenceRowStart = firstPartiallyVisibleRow ?? 0;
+    // When the viewport query returns null nothing is rendered, so there is no cell to measure
+    // against. Keep the search inside the (empty) rendered range instead of opening it to every
+    // row in the grid - otherwise `findColumnReferenceRow` walks the full row x column product,
+    // calling `getCellMetaTransient` on each step, and a single held autofill/`dragToScroll` drag
+    // on a large off-screen grid locks the tab.
+    const columnReferenceRowEnd = lastPartiallyVisibleRow ?? columnReferenceRowStart;
     let foundColumn = null;
     // Check fixed columns first
     if (numberOfFixedColumnsStart > 0) {
@@ -108,21 +226,23 @@ function getCellCoordsFromMousePosition(hotInstance, mouseX, mouseY) {
         const lastFixedColumn = columnIndexMapper.getVisualFromRenderableIndex(numberOfFixedColumnsStart - 1);
         const firstNonHiddenColumn = firstFixedColumn !== null ? columnIndexMapper.getNearestNotHiddenIndex(firstFixedColumn, 1) : null;
         if (firstNonHiddenColumn !== null && lastFixedColumn !== null) {
-            const fixedCell = hotInstance.getCell(firstPartiallyVisibleRow, firstNonHiddenColumn, true);
+            const columnReferenceRow = findColumnReferenceRow(hotInstance, columnReferenceRowStart, columnReferenceRowEnd, firstNonHiddenColumn, lastFixedColumn);
+            const fixedCell = hotInstance.getCell(columnReferenceRow, firstNonHiddenColumn, true);
             if (fixedCell instanceof HTMLElement) {
                 const fixedCellRect = fixedCell.getBoundingClientRect();
                 const fixedRelativeX = isRtl ? fixedCellRect.right - clampedX : clampedX - fixedCellRect.left;
-                foundColumn = findColumnAtX(hotInstance, firstPartiallyVisibleRow, firstNonHiddenColumn, lastFixedColumn, fixedRelativeX);
+                foundColumn = findColumnAtX(hotInstance, columnReferenceRow, firstNonHiddenColumn, lastFixedColumn, fixedRelativeX);
             }
         }
     }
     // If not in fixed columns, check scrollable columns (main table)
     if (foundColumn === null) {
-        const scrollCell = hotInstance.getCell(firstPartiallyVisibleRow, firstPartiallyVisibleColumn, true);
+        const columnReferenceRow = findColumnReferenceRow(hotInstance, columnReferenceRowStart, columnReferenceRowEnd, firstPartiallyVisibleColumn, lastPartiallyVisibleColumn);
+        const scrollCell = hotInstance.getCell(columnReferenceRow, firstPartiallyVisibleColumn, true);
         if (scrollCell instanceof HTMLElement) {
             const scrollCellRect = scrollCell.getBoundingClientRect();
             const scrollRelativeX = isRtl ? scrollCellRect.right - clampedX : clampedX - scrollCellRect.left;
-            foundColumn = findColumnAtX(hotInstance, firstPartiallyVisibleRow, firstPartiallyVisibleColumn, lastPartiallyVisibleColumn, scrollRelativeX);
+            foundColumn = findColumnAtX(hotInstance, columnReferenceRow, firstPartiallyVisibleColumn, lastPartiallyVisibleColumn, scrollRelativeX);
             // Fallback to edge columns if still not found.
             // If `lastPartiallyVisibleColumn` is null (e.g., the HoT is positioned off-screen and
             // viewport queries return invalid indexes), fall back to the global column bounds.
@@ -133,6 +253,21 @@ function getCellCoordsFromMousePosition(hotInstance, mouseX, mouseY) {
             foundColumn = firstPartiallyVisibleColumn ?? 0;
         }
     }
+    if (foundColumn === null) {
+        (0, _errors.throwWithCause)('Failed to resolve cell coordinates from mouse position.');
+    }
+    // Resolve the row against a column that has no vertical merge across the rows being walked.
+    // `findRowAtY` skips a merged cell's spanned rows, so measuring against a vertically merged
+    // column collapses every Y inside the band onto the merge anchor. Neither a fixed column nor
+    // the pointer's column is universally safe (a merge can live in either), so each row-scan
+    // branch picks the first column free of vertical merges within its own row range (DEV-2115).
+    const rowReferenceColumnStart = firstPartiallyVisibleColumn ?? 0;
+    // When the viewport query returns null nothing is rendered, so there is no cell to measure
+    // against. Keep the search inside the (empty) rendered range instead of opening it to every
+    // column in the grid — otherwise `findRowReferenceColumn` walks the full column x row product,
+    // calling `getCellMetaTransient` on each step, and a single held autofill/`dragToScroll` drag
+    // on a large off-screen grid locks the tab.
+    const rowReferenceColumnEnd = lastPartiallyVisibleColumn ?? rowReferenceColumnStart;
     let foundRow = null;
     // Check fixed top rows first
     if (numberOfFixedRowsTop > 0) {
@@ -140,11 +275,12 @@ function getCellCoordsFromMousePosition(hotInstance, mouseX, mouseY) {
         const lastFixedRow = rowIndexMapper.getVisualFromRenderableIndex(numberOfFixedRowsTop - 1);
         const firstNonHiddenRow = firstFixedRow !== null ? rowIndexMapper.getNearestNotHiddenIndex(firstFixedRow, 1) : null;
         if (firstNonHiddenRow !== null && lastFixedRow !== null) {
-            const fixedCell = hotInstance.getCell(firstNonHiddenRow, firstPartiallyVisibleColumn, true);
+            const rowReferenceColumn = findRowReferenceColumn(hotInstance, rowReferenceColumnStart, rowReferenceColumnEnd, firstNonHiddenRow, lastFixedRow);
+            const fixedCell = hotInstance.getCell(firstNonHiddenRow, rowReferenceColumn, true);
             if (fixedCell instanceof HTMLElement) {
                 const fixedCellRect = fixedCell.getBoundingClientRect();
                 const fixedRelativeY = clampedY - fixedCellRect.top;
-                foundRow = findRowAtY(hotInstance, firstPartiallyVisibleColumn, firstNonHiddenRow, lastFixedRow, fixedRelativeY);
+                foundRow = findRowAtY(hotInstance, rowReferenceColumn, firstNonHiddenRow, lastFixedRow, fixedRelativeY);
             }
         }
     }
@@ -156,12 +292,13 @@ function getCellCoordsFromMousePosition(hotInstance, mouseX, mouseY) {
         const bottomStartNonHiddenRow = bottomStartRow !== null ? rowIndexMapper.getNearestNotHiddenIndex(bottomStartRow, 1) : null;
         const bottomEndNonHiddenRow = bottomEndRow !== null ? rowIndexMapper.getNearestNotHiddenIndex(bottomEndRow, -1) : null;
         if (bottomStartNonHiddenRow !== null && bottomEndNonHiddenRow !== null) {
-            const fixedBottomCell = hotInstance.getCell(bottomStartNonHiddenRow, firstPartiallyVisibleColumn, true);
+            const rowReferenceColumn = findRowReferenceColumn(hotInstance, rowReferenceColumnStart, rowReferenceColumnEnd, bottomStartNonHiddenRow, bottomEndNonHiddenRow);
+            const fixedBottomCell = hotInstance.getCell(bottomStartNonHiddenRow, rowReferenceColumn, true);
             if (fixedBottomCell instanceof HTMLElement) {
                 const fixedBottomCellRect = fixedBottomCell.getBoundingClientRect();
                 const fixedBottomRelativeY = clampedY - fixedBottomCellRect.top;
                 if (fixedBottomRelativeY >= 0) {
-                    foundRow = findRowAtY(hotInstance, firstPartiallyVisibleColumn, bottomStartNonHiddenRow, bottomEndNonHiddenRow, fixedBottomRelativeY);
+                    foundRow = findRowAtY(hotInstance, rowReferenceColumn, bottomStartNonHiddenRow, bottomEndNonHiddenRow, fixedBottomRelativeY);
                     if (foundRow === null) {
                         foundRow = bottomEndNonHiddenRow;
                     }
@@ -171,11 +308,17 @@ function getCellCoordsFromMousePosition(hotInstance, mouseX, mouseY) {
     }
     // Check scrollable rows (main table)
     if (foundRow === null) {
-        const scrollCell = hotInstance.getCell(firstPartiallyVisibleRow, firstPartiallyVisibleColumn, true);
+        const scrollRowScanStart = firstPartiallyVisibleRow ?? 0;
+        // Same null-viewport guard as the column bound above: clamp the row scan to the (empty)
+        // rendered range rather than `countRows()`, so the reference-column search cannot walk the
+        // whole grid when nothing is rendered.
+        const scrollRowScanEnd = lastPartiallyVisibleRow ?? scrollRowScanStart;
+        const rowReferenceColumn = findRowReferenceColumn(hotInstance, rowReferenceColumnStart, rowReferenceColumnEnd, scrollRowScanStart, scrollRowScanEnd);
+        const scrollCell = hotInstance.getCell(firstPartiallyVisibleRow, rowReferenceColumn, true);
         if (scrollCell instanceof HTMLElement) {
             const scrollCellRect = scrollCell.getBoundingClientRect();
             const scrollRelativeY = clampedY - scrollCellRect.top;
-            foundRow = findRowAtY(hotInstance, firstPartiallyVisibleColumn, firstPartiallyVisibleRow, lastPartiallyVisibleRow, scrollRelativeY);
+            foundRow = findRowAtY(hotInstance, rowReferenceColumn, firstPartiallyVisibleRow, lastPartiallyVisibleRow, scrollRelativeY);
             // Fallback to edge rows if still not found. If the viewport query returns null
             // (off-screen HoT edge case), use the global row bounds.
             if (foundRow === null) {
@@ -185,7 +328,7 @@ function getCellCoordsFromMousePosition(hotInstance, mouseX, mouseY) {
             foundRow = firstPartiallyVisibleRow ?? 0;
         }
     }
-    if (foundRow === null || foundColumn === null) {
+    if (foundRow === null) {
         (0, _errors.throwWithCause)('Failed to resolve cell coordinates from mouse position.');
     }
     return hotInstance._createCellCoords(foundRow, foundColumn);

package/helpers/dom/cellCoords.mjs

@@ -21,7 +21,7 @@ import { throwWithCause } from '../errors.mjs';
             return column;
         }
         accumulatedX += width;
-        const { colspan } = hotInstance.getCellMeta(row, column);
+        const { colspan } = hotInstance.getCellMetaTransient(row, column);
         if (colspan !== undefined && colspan > 1) {
             column += colspan - 1;
         }
@@ -49,13 +49,117 @@ import { throwWithCause } from '../errors.mjs';
             return row;
         }
         accumulatedY += height;
-        const { rowspan } = hotInstance.getCellMeta(row, column);
+        const { rowspan } = hotInstance.getCellMetaTransient(row, column);
         if (rowspan !== undefined && rowspan > 1) {
             row += rowspan - 1;
         }
     }
     return null;
 }
+/**
+ * Finds a column suitable for mapping a Y coordinate to a row: the first column in the range
+ * whose cells across the scanned rows each occupy their own single row. `findRowAtY` walks one
+ * column's cell heights and skips a merged cell's spanned rows, so it is distorted by a cell
+ * that spans multiple rows — a vertical-merge anchor or any of its slaves. Such a column is
+ * detected two ways: `rowspan > 1` on the anchor's meta, and element identity, since every row
+ * inside a vertical merge resolves to the same rendered cell. A purely horizontal merge resolves
+ * to a distinct, single-row master cell per row, so its columns stay valid. A merge in one column
+ * must not distort the row lookup used for other columns (DEV-2115).
+ *
+ * The scanned row range must match the range the returned column will be walked over (the frozen
+ * overlays and the scrollable body are resolved separately), so a merge confined to frozen rows
+ * cannot leak into the body lookup or vice versa.
+ *
+ * @param {Handsontable} hotInstance The Handsontable instance.
+ * @param {number} startColumn First column to consider.
+ * @param {number} endColumn Last column to consider (inclusive).
+ * @param {number} startRow First row of the scanned range.
+ * @param {number} endRow Last row of the scanned range (inclusive).
+ * @returns {number} A column index free of vertical-merge distortion, or `startColumn` if none qualifies.
+ */ function findRowReferenceColumn(hotInstance, startColumn, endColumn, startRow, endRow) {
+    for(let column = startColumn; column <= endColumn; column++){
+        let spansMultipleRows = false;
+        let hasRenderableCell = false;
+        let previousCell = null;
+        for(let row = startRow; row <= endRow; row++){
+            const cell = hotInstance.getCell(row, column, true);
+            const { rowspan } = hotInstance.getCellMetaTransient(row, column);
+            // A vertically merged cell reports `rowspan > 1` on its anchor and resolves to the same
+            // rendered element for every row it covers; either signal marks the column as distorting.
+            if (rowspan !== undefined && rowspan > 1 || cell !== null && cell === previousCell) {
+                spansMultipleRows = true;
+                break;
+            }
+            if (cell !== null) {
+                previousCell = cell;
+                hasRenderableCell = true;
+            }
+        }
+        // A hidden column (e.g. `hiddenColumns`) renders no cells, so `findRowAtY` cannot measure
+        // against it. Require at least one renderable cell so a hidden column between the merged
+        // column and a usable one is skipped rather than picked as the reference.
+        if (!spansMultipleRows && hasRenderableCell) {
+            return column;
+        }
+    }
+    // Best-effort fallback: every column in the scanned range is vertically merged (e.g. a grouped
+    // report grid whose visible columns all merge across the same band). No column is free of the
+    // distortion, so `findRowAtY` will still collapse the band onto its anchor — `startColumn` is
+    // simply the least-surprising choice. This is a known narrow case of DEV-2115, not a bug here.
+    return startColumn;
+}
+/**
+ * Finds a row suitable for mapping an X coordinate to a column: the first row in the range
+ * whose cells across the scanned columns each occupy their own single column. `findColumnAtX`
+ * walks one row's cell widths and skips a merged cell's spanned columns, so it is distorted by a
+ * cell that spans multiple columns - a horizontal-merge anchor or any of its slaves. Such a row
+ * is detected two ways: `colspan > 1` on the anchor's meta, and element identity, since every
+ * column inside a horizontal merge resolves to the same rendered cell. A purely vertical merge
+ * resolves to a distinct, single-column master cell per column, so its rows stay valid. A merge
+ * in one row must not distort the column lookup used for other rows (DEV-2124).
+ *
+ * The scanned column range must match the range the returned row will be walked over (the frozen
+ * overlays and the scrollable body are resolved separately), so a merge confined to frozen
+ * columns cannot leak into the body lookup or vice versa.
+ *
+ * @param {Handsontable} hotInstance The Handsontable instance.
+ * @param {number} startRow First row to consider.
+ * @param {number} endRow Last row to consider (inclusive).
+ * @param {number} startColumn First column of the scanned range.
+ * @param {number} endColumn Last column of the scanned range (inclusive).
+ * @returns {number} A row index free of horizontal-merge distortion, or `startRow` if none qualifies.
+ */ function findColumnReferenceRow(hotInstance, startRow, endRow, startColumn, endColumn) {
+    for(let row = startRow; row <= endRow; row++){
+        let spansMultipleColumns = false;
+        let hasRenderableCell = false;
+        let previousCell = null;
+        for(let column = startColumn; column <= endColumn; column++){
+            const cell = hotInstance.getCell(row, column, true);
+            const { colspan } = hotInstance.getCellMetaTransient(row, column);
+            // A horizontally merged cell reports `colspan > 1` on its anchor and resolves to the same
+            // rendered element for every column it covers; either signal marks the row as distorting.
+            if (colspan !== undefined && colspan > 1 || cell !== null && cell === previousCell) {
+                spansMultipleColumns = true;
+                break;
+            }
+            if (cell !== null) {
+                previousCell = cell;
+                hasRenderableCell = true;
+            }
+        }
+        // A hidden row (e.g. `hiddenRows`) renders no cells, so `findColumnAtX` cannot measure
+        // against it. Require at least one renderable cell so a hidden row between the merged
+        // row and a usable one is skipped rather than picked as the reference.
+        if (!spansMultipleColumns && hasRenderableCell) {
+            return row;
+        }
+    }
+    // Best-effort fallback: every row in the scanned range is horizontally merged (e.g. a banded
+    // report grid whose visible rows all merge across the same columns). No row is free of the
+    // distortion, so `findColumnAtX` will still collapse the band onto its anchor - `startRow` is
+    // simply the least-surprising choice. This is a known narrow case of DEV-2124, not a bug here.
+    return startRow;
+}
 /**
  * Get the cell coordinates from the mouse position. When the mouse is outside of the table,
  * the nearest cell is returned.
@@ -99,6 +203,20 @@ import { throwWithCause } from '../errors.mjs';
     const tableViewportBottom = view.isVerticallyScrollableByWindow() ? rootWindow.innerHeight : tableOffset.top + view.getViewportHeight() + columnHeaderHeight;
     const clampedX = clamp(mouseX, tableViewportLeft, tableViewportRight);
     const clampedY = clamp(mouseY, tableViewportTop, tableViewportBottom);
+    // Resolve the column against a row that has no horizontal merge across the columns being
+    // walked. `findColumnAtX` skips a merged cell's spanned columns, so measuring against a
+    // horizontally merged row collapses every X inside the band onto the merge anchor - and when
+    // the anchor is scrolled out of view the band's full width is counted once per slave column.
+    // Neither a fixed row nor the pointer's row is universally safe (a merge can live in either),
+    // so each column-scan branch picks the first row free of horizontal merges within its own
+    // column range (DEV-2124).
+    const columnReferenceRowStart = firstPartiallyVisibleRow ?? 0;
+    // When the viewport query returns null nothing is rendered, so there is no cell to measure
+    // against. Keep the search inside the (empty) rendered range instead of opening it to every
+    // row in the grid - otherwise `findColumnReferenceRow` walks the full row x column product,
+    // calling `getCellMetaTransient` on each step, and a single held autofill/`dragToScroll` drag
+    // on a large off-screen grid locks the tab.
+    const columnReferenceRowEnd = lastPartiallyVisibleRow ?? columnReferenceRowStart;
     let foundColumn = null;
     // Check fixed columns first
     if (numberOfFixedColumnsStart > 0) {
@@ -106,21 +224,23 @@ import { throwWithCause } from '../errors.mjs';
         const lastFixedColumn = columnIndexMapper.getVisualFromRenderableIndex(numberOfFixedColumnsStart - 1);
         const firstNonHiddenColumn = firstFixedColumn !== null ? columnIndexMapper.getNearestNotHiddenIndex(firstFixedColumn, 1) : null;
         if (firstNonHiddenColumn !== null && lastFixedColumn !== null) {
-            const fixedCell = hotInstance.getCell(firstPartiallyVisibleRow, firstNonHiddenColumn, true);
+            const columnReferenceRow = findColumnReferenceRow(hotInstance, columnReferenceRowStart, columnReferenceRowEnd, firstNonHiddenColumn, lastFixedColumn);
+            const fixedCell = hotInstance.getCell(columnReferenceRow, firstNonHiddenColumn, true);
             if (fixedCell instanceof HTMLElement) {
                 const fixedCellRect = fixedCell.getBoundingClientRect();
                 const fixedRelativeX = isRtl ? fixedCellRect.right - clampedX : clampedX - fixedCellRect.left;
-                foundColumn = findColumnAtX(hotInstance, firstPartiallyVisibleRow, firstNonHiddenColumn, lastFixedColumn, fixedRelativeX);
+                foundColumn = findColumnAtX(hotInstance, columnReferenceRow, firstNonHiddenColumn, lastFixedColumn, fixedRelativeX);
             }
         }
     }
     // If not in fixed columns, check scrollable columns (main table)
     if (foundColumn === null) {
-        const scrollCell = hotInstance.getCell(firstPartiallyVisibleRow, firstPartiallyVisibleColumn, true);
+        const columnReferenceRow = findColumnReferenceRow(hotInstance, columnReferenceRowStart, columnReferenceRowEnd, firstPartiallyVisibleColumn, lastPartiallyVisibleColumn);
+        const scrollCell = hotInstance.getCell(columnReferenceRow, firstPartiallyVisibleColumn, true);
         if (scrollCell instanceof HTMLElement) {
             const scrollCellRect = scrollCell.getBoundingClientRect();
             const scrollRelativeX = isRtl ? scrollCellRect.right - clampedX : clampedX - scrollCellRect.left;
-            foundColumn = findColumnAtX(hotInstance, firstPartiallyVisibleRow, firstPartiallyVisibleColumn, lastPartiallyVisibleColumn, scrollRelativeX);
+            foundColumn = findColumnAtX(hotInstance, columnReferenceRow, firstPartiallyVisibleColumn, lastPartiallyVisibleColumn, scrollRelativeX);
             // Fallback to edge columns if still not found.
             // If `lastPartiallyVisibleColumn` is null (e.g., the HoT is positioned off-screen and
             // viewport queries return invalid indexes), fall back to the global column bounds.
@@ -131,6 +251,21 @@ import { throwWithCause } from '../errors.mjs';
             foundColumn = firstPartiallyVisibleColumn ?? 0;
         }
     }
+    if (foundColumn === null) {
+        throwWithCause('Failed to resolve cell coordinates from mouse position.');
+    }
+    // Resolve the row against a column that has no vertical merge across the rows being walked.
+    // `findRowAtY` skips a merged cell's spanned rows, so measuring against a vertically merged
+    // column collapses every Y inside the band onto the merge anchor. Neither a fixed column nor
+    // the pointer's column is universally safe (a merge can live in either), so each row-scan
+    // branch picks the first column free of vertical merges within its own row range (DEV-2115).
+    const rowReferenceColumnStart = firstPartiallyVisibleColumn ?? 0;
+    // When the viewport query returns null nothing is rendered, so there is no cell to measure
+    // against. Keep the search inside the (empty) rendered range instead of opening it to every
+    // column in the grid — otherwise `findRowReferenceColumn` walks the full column x row product,
+    // calling `getCellMetaTransient` on each step, and a single held autofill/`dragToScroll` drag
+    // on a large off-screen grid locks the tab.
+    const rowReferenceColumnEnd = lastPartiallyVisibleColumn ?? rowReferenceColumnStart;
     let foundRow = null;
     // Check fixed top rows first
     if (numberOfFixedRowsTop > 0) {
@@ -138,11 +273,12 @@ import { throwWithCause } from '../errors.mjs';
         const lastFixedRow = rowIndexMapper.getVisualFromRenderableIndex(numberOfFixedRowsTop - 1);
         const firstNonHiddenRow = firstFixedRow !== null ? rowIndexMapper.getNearestNotHiddenIndex(firstFixedRow, 1) : null;
         if (firstNonHiddenRow !== null && lastFixedRow !== null) {
-            const fixedCell = hotInstance.getCell(firstNonHiddenRow, firstPartiallyVisibleColumn, true);
+            const rowReferenceColumn = findRowReferenceColumn(hotInstance, rowReferenceColumnStart, rowReferenceColumnEnd, firstNonHiddenRow, lastFixedRow);
+            const fixedCell = hotInstance.getCell(firstNonHiddenRow, rowReferenceColumn, true);
             if (fixedCell instanceof HTMLElement) {
                 const fixedCellRect = fixedCell.getBoundingClientRect();
                 const fixedRelativeY = clampedY - fixedCellRect.top;
-                foundRow = findRowAtY(hotInstance, firstPartiallyVisibleColumn, firstNonHiddenRow, lastFixedRow, fixedRelativeY);
+                foundRow = findRowAtY(hotInstance, rowReferenceColumn, firstNonHiddenRow, lastFixedRow, fixedRelativeY);
             }
         }
     }
@@ -154,12 +290,13 @@ import { throwWithCause } from '../errors.mjs';
         const bottomStartNonHiddenRow = bottomStartRow !== null ? rowIndexMapper.getNearestNotHiddenIndex(bottomStartRow, 1) : null;
         const bottomEndNonHiddenRow = bottomEndRow !== null ? rowIndexMapper.getNearestNotHiddenIndex(bottomEndRow, -1) : null;
         if (bottomStartNonHiddenRow !== null && bottomEndNonHiddenRow !== null) {
-            const fixedBottomCell = hotInstance.getCell(bottomStartNonHiddenRow, firstPartiallyVisibleColumn, true);
+            const rowReferenceColumn = findRowReferenceColumn(hotInstance, rowReferenceColumnStart, rowReferenceColumnEnd, bottomStartNonHiddenRow, bottomEndNonHiddenRow);
+            const fixedBottomCell = hotInstance.getCell(bottomStartNonHiddenRow, rowReferenceColumn, true);
             if (fixedBottomCell instanceof HTMLElement) {
                 const fixedBottomCellRect = fixedBottomCell.getBoundingClientRect();
                 const fixedBottomRelativeY = clampedY - fixedBottomCellRect.top;
                 if (fixedBottomRelativeY >= 0) {
-                    foundRow = findRowAtY(hotInstance, firstPartiallyVisibleColumn, bottomStartNonHiddenRow, bottomEndNonHiddenRow, fixedBottomRelativeY);
+                    foundRow = findRowAtY(hotInstance, rowReferenceColumn, bottomStartNonHiddenRow, bottomEndNonHiddenRow, fixedBottomRelativeY);
                     if (foundRow === null) {
                         foundRow = bottomEndNonHiddenRow;
                     }
@@ -169,11 +306,17 @@ import { throwWithCause } from '../errors.mjs';
     }
     // Check scrollable rows (main table)
     if (foundRow === null) {
-        const scrollCell = hotInstance.getCell(firstPartiallyVisibleRow, firstPartiallyVisibleColumn, true);
+        const scrollRowScanStart = firstPartiallyVisibleRow ?? 0;
+        // Same null-viewport guard as the column bound above: clamp the row scan to the (empty)
+        // rendered range rather than `countRows()`, so the reference-column search cannot walk the
+        // whole grid when nothing is rendered.
+        const scrollRowScanEnd = lastPartiallyVisibleRow ?? scrollRowScanStart;
+        const rowReferenceColumn = findRowReferenceColumn(hotInstance, rowReferenceColumnStart, rowReferenceColumnEnd, scrollRowScanStart, scrollRowScanEnd);
+        const scrollCell = hotInstance.getCell(firstPartiallyVisibleRow, rowReferenceColumn, true);
         if (scrollCell instanceof HTMLElement) {
             const scrollCellRect = scrollCell.getBoundingClientRect();
             const scrollRelativeY = clampedY - scrollCellRect.top;
-            foundRow = findRowAtY(hotInstance, firstPartiallyVisibleColumn, firstPartiallyVisibleRow, lastPartiallyVisibleRow, scrollRelativeY);
+            foundRow = findRowAtY(hotInstance, rowReferenceColumn, firstPartiallyVisibleRow, lastPartiallyVisibleRow, scrollRelativeY);
             // Fallback to edge rows if still not found. If the viewport query returns null
             // (off-screen HoT edge case), use the global row bounds.
             if (foundRow === null) {
@@ -183,7 +326,7 @@ import { throwWithCause } from '../errors.mjs';
             foundRow = firstPartiallyVisibleRow ?? 0;
         }
     }
-    if (foundRow === null || foundColumn === null) {
+    if (foundRow === null) {
         throwWithCause('Failed to resolve cell coordinates from mouse position.');
     }
     return hotInstance._createCellCoords(foundRow, foundColumn);

package/helpers/dom/element.d.ts

@@ -1,3 +1,4 @@
+import type { SanitizerContext } from '../../core/settings';
 /**
  * Get the parent of the specified node in the DOM tree.
  *
@@ -172,20 +173,34 @@ export declare const HTML_CHARACTERS: RegExp;
  * collapse into a single warning per Handsontable instance.
  */
 export declare const SANITIZER_WARN_KEY = "sanitizer";
+/**
+ * Builds the missing-sanitizer warning. Every surface that writes raw HTML uses this, whether it
+ * goes through `fastInnerHTML` or sanitizes a string first (`utils/sanitizer.ts`), so the wording
+ * cannot drift between them.
+ *
+ * It lives here rather than beside its second caller because `utils/sanitizer.ts` already imports
+ * from this module, and the reverse direction would be a cycle. That makes it public through
+ * `Handsontable.dom`, like `HTML_CHARACTERS` and `SANITIZER_WARN_KEY` above it - accepted
+ * deliberately: it is a pure string builder, and it is useful to anyone writing their own sink.
+ *
+ * @param {string} context The write surface that is about to receive raw HTML.
+ * @returns {string} The warning message.
+ */
+export declare function missingSanitizerMessage(context: string): string;
 /**
  * Insert content into element trying to avoid innerHTML method.
  *
  * @param {HTMLElement} element An element to write into.
  * @param {string} content The text to write.
- * @param {boolean|function(string, string): string} [sanitizer] When a function, use it as the sanitizer; when `false`,
+ * @param {boolean|function(string, SanitizerContext): string} [sanitizer] When a function, use it as the sanitizer; when `false`,
  * write the content as raw HTML on purpose (no warning); when `true` (the default), write the content as raw HTML and
  * warn once that no sanitizer is configured.
- * @param {string} [context] The sanitization context passed as the second argument to a custom sanitizer function, and
+ * @param {SanitizerContext} [context] The sanitization context passed as the second argument to a custom sanitizer function, and
  * used in the missing-sanitizer warning to identify the write surface.
- * @param {object} [scope] Object the "warn once" state is bound to (for example, `hot.rootGridElement`), so the warning
- * is shown at most once per Handsontable instance.
+ * @param {object} [scope] Object the "warn once" state is bound to (`hot.rootElement` at every call site
+ * inside the grid), so the warning is shown at most once per Handsontable instance.
  */
-export declare function fastInnerHTML(element: HTMLElement, content: string, sanitizer?: boolean | ((html: string, context: string) => string), context?: string, scope?: object): void;
+export declare function fastInnerHTML(element: HTMLElement, content: string, sanitizer?: boolean | ((html: string, context: SanitizerContext) => string), context?: SanitizerContext, scope?: object): void;
 /**
  * Insert text content into element.
  *
@@ -447,10 +462,14 @@ export declare function isDetached(element: HTMLElement): boolean;
  * Set up an observer to recognize when the provided element first becomes visible and trigger a callback when it
  * happens.
  *
+ * The observer is returned so the caller can disconnect it earlier - a pending delivery carries the state from
+ * the moment its snapshot was taken, so it can arrive after the observed element (or its owner) is gone.
+ *
  * @param {HTMLElement} elementToBeObserved Element to be observed.
  * @param {Function} callback The callback function.
+ * @returns {IntersectionObserver} The observer watching the element.
  */
-export declare function observeVisibilityChangeOnce(elementToBeObserved: HTMLElement, callback: () => void): void;
+export declare function observeVisibilityChangeOnce(elementToBeObserved: HTMLElement, callback: () => void): IntersectionObserver;
 /**
  * Add a `contenteditable` attribute, select the contents and optionally add the `invisibleSelection`
  * class to the provided element.
@@ -502,10 +521,30 @@ export declare function isHTMLInputElement(element: HTMLElement): element is HTM
 /**
  * Check if the node is a ShadowRoot (a document fragment attached to a host element).
  *
- * @param {Node} node Node to check.
+ * @param {Node|EventTarget} node Node to check.
  * @returns {boolean} `true` if the node is a ShadowRoot.
  */
-export declare function isShadowRoot(node: Node): node is ShadowRoot;
+export declare function isShadowRoot(node: Node | EventTarget): node is ShadowRoot;
+/**
+ * Gets the chain of shadow host elements the node is rendered within, ordered from the
+ * closest host outward to the host attached to the document.
+ *
+ * @param {Node} node The node to read the host chain from.
+ * @returns {HTMLElement[]} The shadow host elements; empty when the node is not in a Shadow DOM tree.
+ */
+export declare function getShadowHostChain(node: Node): HTMLElement[];
+/**
+ * Gets the deepest active (focused) element in the document. When the focus is inside
+ * a Shadow DOM tree, `document.activeElement` points at the shadow host instead of the
+ * focused element. This helper descends through the open shadow roots and returns
+ * the element that actually holds the focus.
+ *
+ * @param {Document} rootDocument The document to read the active element from.
+ * @returns {Element|null} The deepest focused element. The browser reports `document.body`
+ * when no other element holds the focus; `null` appears only in edge cases such as
+ * a document with no body.
+ */
+export declare function getDeepActiveElement(rootDocument: Document): Element | null;
 /**
  * Gets a child node at the specified index cast to the specified HTML element type.
  *