handsontable 18.0.0 → 18.1.0-rc1

package/helpers/array.mjs

@@ -185,6 +185,51 @@
  */ export function arrayFlatten(array) {
     return arrayReduce(array, (initial, value)=>initial.concat(Array.isArray(value) ? arrayFlatten(value) : value), []);
 }
+/**
+ * Removes the elements at the given indexes from the array. The array is compacted in one
+ * pass and mutated in place, so external references to it stay valid. Cost is O(array length)
+ * regardless of how many indexes are removed - unlike one `splice` call per removed index,
+ * which re-shifts the tail every time.
+ *
+ * @param {Array} array The array to mutate.
+ * @param {Set<number>} indexes The indexes of the elements to remove.
+ * @returns {Array} Returns the same, mutated array.
+ */ export function removeIndexesInPlace(array, indexes) {
+    let writeIndex = 0;
+    for(let readIndex = 0; readIndex < array.length; readIndex++){
+        if (!indexes.has(readIndex)) {
+            array[writeIndex] = array[readIndex];
+            writeIndex += 1;
+        }
+    }
+    array.length = writeIndex;
+    return array;
+}
+/**
+ * Inserts `amount` copies of `value` into the array at the given index. The tail is shifted
+ * right once by `amount` and the array is mutated in place, so external references to it stay
+ * valid. An index greater than the array length is clamped to it (the values are appended),
+ * matching `Array.prototype.splice` semantics. Cost is O(array length + amount) regardless of
+ * `amount` - unlike one `splice` call per inserted value, which re-shifts the tail every time.
+ *
+ * @param {Array} array The array to mutate.
+ * @param {number} index The index at which to insert the values.
+ * @param {number} amount The number of copies to insert.
+ * @param {*} value The value to insert.
+ * @returns {Array} Returns the same, mutated array.
+ */ export function insertValuesInPlace(array, index, amount, value) {
+    if (amount <= 0) {
+        return array;
+    }
+    const oldLength = array.length;
+    const insertAt = Math.min(index, oldLength);
+    array.length = oldLength + amount;
+    for(let i = oldLength - 1; i >= insertAt; i--){
+        array[i + amount] = array[i];
+    }
+    array.fill(value, insertAt, insertAt + amount);
+    return array;
+}
 /**
  * Unique values in the array.
  *
@@ -192,8 +237,10 @@
  * @returns {Array}
  */ export function arrayUnique(array) {
     const unique = [];
+    const seen = new Set();
     arrayEach(array, (value)=>{
-        if (unique.indexOf(value) === -1) {
+        if (!seen.has(value)) {
+            seen.add(value);
             unique.push(value);
         }
     });
@@ -210,7 +257,8 @@
     ];
     let filteredFirstArray = first;
     arrayEach(rest, (array)=>{
-        filteredFirstArray = filteredFirstArray.filter((value)=>!array.includes(value));
+        const lookup = new Set(array);
+        filteredFirstArray = filteredFirstArray.filter((value)=>!lookup.has(value));
     });
     return filteredFirstArray;
 }
@@ -231,11 +279,15 @@
             arrays.push(arg);
         }
     });
-    const isMatch = comparator ? (value, array)=>array.some((item)=>comparator(value, item)) : (value, array)=>array.includes(value);
     const [first, ...rest] = arrays;
     let filteredFirstArray = first;
     arrayEach(rest, (array)=>{
-        filteredFirstArray = filteredFirstArray.filter((value)=>isMatch(value, array));
+        if (comparator) {
+            filteredFirstArray = filteredFirstArray.filter((value)=>array.some((item)=>comparator(value, item)));
+        } else {
+            const lookup = new Set(array);
+            filteredFirstArray = filteredFirstArray.filter((value)=>lookup.has(value));
+        }
     });
     return filteredFirstArray;
 }

package/helpers/dateTime.d.ts

@@ -26,6 +26,20 @@ export declare function parseToLocalTime(value: unknown): Date | null;
  * Checks if a string is a valid time in HH:mm, HH:mm:ss, or HH:mm:ss.SSS format.
  */
 export declare function isValidTime(value: unknown): value is string;
+/**
+ * ISO 8601 date-time pattern. The date part is required; the time part is optional and may use a
+ * `T` or space separator, with optional seconds and fractional seconds (`YYYY-MM-DD`,
+ * `YYYY-MM-DDTHH:mm`, `YYYY-MM-DDTHH:mm:ss`, `YYYY-MM-DD HH:mm:ss.SSS`).
+ */
+export declare const ISO_DATETIME_REGEX: RegExp;
+/**
+ * Parses an ISO 8601 date-time string to a local Date. Date-only values become local midnight.
+ */
+export declare function parseToLocalDateTime(value: unknown): Date | null;
+/**
+ * Checks if a string is a valid ISO 8601 date-time, enforcing the day-of-month calendar bound.
+ */
+export declare function isValidISODateTime(value: unknown): value is string;
 /**
  * Returns a Date at local midnight for today.
  *

package/helpers/dateTime.js

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get ISO_DATETIME_REGEX () {
+        return ISO_DATETIME_REGEX;
+    },
     get ISO_DATE_REGEX () {
         return ISO_DATE_REGEX;
     },
@@ -30,12 +33,18 @@ _export(exports, {
     get isValidISODate () {
         return isValidISODate;
     },
+    get isValidISODateTime () {
+        return isValidISODateTime;
+    },
     get isValidTime () {
         return isValidTime;
     },
     get parseToLocalDate () {
         return parseToLocalDate;
     },
+    get parseToLocalDateTime () {
+        return parseToLocalDateTime;
+    },
     get parseToLocalTime () {
         return parseToLocalTime;
     }
@@ -59,12 +68,41 @@ function parseToLocalDate(value) {
     }
     return null;
 }
+/**
+ * Number of days in each month for a non-leap year, indexed by zero-based month.
+ */ const DAYS_IN_MONTH = [
+    31,
+    28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+];
+/**
+ * Checks if a year is a leap year in the proleptic Gregorian calendar.
+ */ function isLeapYear(year) {
+    return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
 function isValidISODate(value) {
     if (typeof value !== 'string' || !ISO_DATE_REGEX.test(value)) {
         return false;
     }
-    const date = new Date(value);
-    return !Number.isNaN(date.getTime()) && value === date.toISOString().slice(0, 10);
+    // The regex guarantees the YYYY-MM-DD shape with month 01-12 and day 01-31. The only remaining
+    // check is the calendar bound: that the day fits the given month and year (e.g. rejecting 02-30,
+    // 04-31, or 02-29 in a non-leap year). Doing this arithmetically avoids constructing a Date and
+    // round-tripping through toISOString() for every cell, which dominated load time on large
+    // date-typed grids.
+    const year = +value.slice(0, 4);
+    const month = +value.slice(5, 7);
+    const day = +value.slice(8, 10);
+    const maxDay = month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1];
+    return day <= maxDay;
 }
 const TIME_REGEX = /^([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d)(?:\.(\d{1,3}))?)?$/;
 function parseToLocalTime(value) {
@@ -88,6 +126,40 @@ function parseToLocalTime(value) {
 function isValidTime(value) {
     return typeof value === 'string' && TIME_REGEX.test(value);
 }
+const ISO_DATETIME_REGEX = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])(?:[T ]([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d)(?:\.(\d{1,3}))?)?)?$/;
+function parseToLocalDateTime(value) {
+    if ((0, _mixed.isEmpty)(value)) {
+        return null;
+    }
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const match = ISO_DATETIME_REGEX.exec(value);
+    if (!match) {
+        return null;
+    }
+    const [datePart] = value.split(/[T ]/);
+    const [year, month, day] = datePart.split('-').map(Number);
+    const hours = match[3] !== undefined ? Number(match[3]) : 0;
+    const minutes = match[4] !== undefined ? Number(match[4]) : 0;
+    const seconds = match[5] !== undefined ? Number(match[5]) : 0;
+    const milliseconds = match[6] !== undefined ? Number(match[6].padEnd(3, '0').slice(0, 3)) : 0;
+    return new Date(year, month - 1, day, hours, minutes, seconds, milliseconds);
+}
+function isValidISODateTime(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    const match = ISO_DATETIME_REGEX.exec(value);
+    if (!match) {
+        return false;
+    }
+    const year = +value.slice(0, 4);
+    const month = +match[1];
+    const day = +match[2];
+    const maxDay = month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1];
+    return day <= maxDay;
+}
 function getTodayLocalDate() {
     const now = new Date();
     return new Date(now.getFullYear(), now.getMonth(), now.getDate());

package/helpers/dateTime.mjs

@@ -23,14 +23,43 @@ import { isEmpty } from './mixed.mjs';
     }
     return null;
 }
+/**
+ * Number of days in each month for a non-leap year, indexed by zero-based month.
+ */ const DAYS_IN_MONTH = [
+    31,
+    28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+];
+/**
+ * Checks if a year is a leap year in the proleptic Gregorian calendar.
+ */ function isLeapYear(year) {
+    return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
 /**
  * Checks if a string is a valid ISO 8601 date.
  */ export function isValidISODate(value) {
     if (typeof value !== 'string' || !ISO_DATE_REGEX.test(value)) {
         return false;
     }
-    const date = new Date(value);
-    return !Number.isNaN(date.getTime()) && value === date.toISOString().slice(0, 10);
+    // The regex guarantees the YYYY-MM-DD shape with month 01-12 and day 01-31. The only remaining
+    // check is the calendar bound: that the day fits the given month and year (e.g. rejecting 02-30,
+    // 04-31, or 02-29 in a non-leap year). Doing this arithmetically avoids constructing a Date and
+    // round-tripping through toISOString() for every cell, which dominated load time on large
+    // date-typed grids.
+    const year = +value.slice(0, 4);
+    const month = +value.slice(5, 7);
+    const day = +value.slice(8, 10);
+    const maxDay = month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1];
+    return day <= maxDay;
 }
 /**
  * Time pattern: HH:mm, HH:mm:ss, or HH:mm:ss.SSS (24-hour).
@@ -60,6 +89,48 @@ import { isEmpty } from './mixed.mjs';
  */ export function isValidTime(value) {
     return typeof value === 'string' && TIME_REGEX.test(value);
 }
+/**
+ * ISO 8601 date-time pattern. The date part is required; the time part is optional and may use a
+ * `T` or space separator, with optional seconds and fractional seconds (`YYYY-MM-DD`,
+ * `YYYY-MM-DDTHH:mm`, `YYYY-MM-DDTHH:mm:ss`, `YYYY-MM-DD HH:mm:ss.SSS`).
+ */ export const ISO_DATETIME_REGEX = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])(?:[T ]([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d)(?:\.(\d{1,3}))?)?)?$/;
+/**
+ * Parses an ISO 8601 date-time string to a local Date. Date-only values become local midnight.
+ */ export function parseToLocalDateTime(value) {
+    if (isEmpty(value)) {
+        return null;
+    }
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const match = ISO_DATETIME_REGEX.exec(value);
+    if (!match) {
+        return null;
+    }
+    const [datePart] = value.split(/[T ]/);
+    const [year, month, day] = datePart.split('-').map(Number);
+    const hours = match[3] !== undefined ? Number(match[3]) : 0;
+    const minutes = match[4] !== undefined ? Number(match[4]) : 0;
+    const seconds = match[5] !== undefined ? Number(match[5]) : 0;
+    const milliseconds = match[6] !== undefined ? Number(match[6].padEnd(3, '0').slice(0, 3)) : 0;
+    return new Date(year, month - 1, day, hours, minutes, seconds, milliseconds);
+}
+/**
+ * Checks if a string is a valid ISO 8601 date-time, enforcing the day-of-month calendar bound.
+ */ export function isValidISODateTime(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    const match = ISO_DATETIME_REGEX.exec(value);
+    if (!match) {
+        return false;
+    }
+    const year = +value.slice(0, 4);
+    const month = +match[1];
+    const day = +match[2];
+    const maxDay = month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1];
+    return day <= maxDay;
+}
 /**
  * Returns a Date at local midnight for today.
  *

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);