@rickcedwhat/playwright-smart-table 6.18.0 → 6.20.0

package/dist/smartRow.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const rowResolution_1 = require("./engine/rowResolution");
 const fill_1 = require("./strategies/fill");
 const stringUtils_1 = require("./utils/stringUtils");
 const debugUtils_1 = require("./utils/debugUtils");
@@ -146,38 +147,6 @@ const _navigateToCell = async (params) => {
         if (typeof rowIndex !== 'number') {
             throw new Error('Row index is required for navigation');
         }
-        const navigateOnce = async () => {
-            // Get current position again to be sure
-            let currRow = 0;
-            let currCol = 0;
-            if (config.strategies.getActiveCell) {
-                const ac = await config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
-                if (ac) {
-                    currRow = ac.rowIndex;
-                    currCol = ac.columnIndex;
-                }
-            }
-            const rDiff = rowIndex - currRow;
-            const cDiff = index - currCol;
-            // Move one step vertically
-            if (rDiff > 0 && nav.goDown) {
-                (0, debugUtils_1.logDebug)(config, 'verbose', '_navigateToCell: moving down');
-                await nav.goDown(context);
-            }
-            else if (rDiff < 0 && nav.goUp) {
-                (0, debugUtils_1.logDebug)(config, 'verbose', '_navigateToCell: moving up');
-                await nav.goUp(context);
-            }
-            // Move one step horizontally
-            if (cDiff > 0 && nav.goRight) {
-                (0, debugUtils_1.logDebug)(config, 'verbose', '_navigateToCell: moving right');
-                await nav.goRight(context);
-            }
-            else if (cDiff < 0 && nav.goLeft) {
-                (0, debugUtils_1.logDebug)(config, 'verbose', '_navigateToCell: moving left');
-                await nav.goLeft(context);
-            }
-        };
         if (await targetReached()) {
             // Already there. If we have a barrier, check-in to stay in lock-step.
             if (barrier)
@@ -311,7 +280,7 @@ const _navigateToCell = async (params) => {
         else {
             navResult = await navigateUntilReached();
         }
-        // navigateUntilReached may return a Locator it found mid-navigation; duck-type check via .count() (public API) rather than the internal _isLocator flag
+        // navigateUntilReached may return a Locator it found mid-navigation
         if (navResult && typeof navResult.count === 'function') {
             const loc = navResult;
             if (await loc.count() > 0)
@@ -353,9 +322,13 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
     smart._barrier = barrier;
     // Attach Methods
     smart.getCell = (colName) => {
+        var _a, _b;
+        if ((_a = config.syntheticColumns) === null || _a === void 0 ? void 0 : _a[colName]) {
+            throw new Error(`Column "${colName}" is synthetic (no DOM cell) — use getValue("${colName}") or toJSON() instead`);
+        }
         const idx = map.get(colName);
         if (idx === undefined) {
-            throw new Error((0, stringUtils_1.buildColumnNotFoundError)(colName, Array.from(map.keys())));
+            throw new Error((0, stringUtils_1.buildColumnNotFoundError)(colName, [...map.keys(), ...Object.keys((_b = config.syntheticColumns) !== null && _b !== void 0 ? _b : {})]));
         }
         let baseLocator;
         if (config.strategies.getCellLocator) {
@@ -413,8 +386,145 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
     smart.wasFound = () => {
         return !smart[sentinel_1.SENTINEL_ROW];
     };
+    smart.getValue = async (colName) => {
+        var _a, _b, _c;
+        const syntheticDef = (_a = config.syntheticColumns) === null || _a === void 0 ? void 0 : _a[colName];
+        if (syntheticDef) {
+            const guardedRow = Object.create(smart);
+            guardedRow.getValue = async (innerCol) => {
+                var _a;
+                if ((_a = config.syntheticColumns) === null || _a === void 0 ? void 0 : _a[innerCol]) {
+                    throw new Error(`[SmartTable] Synthetic column "${innerCol}" cannot be read from inside another synthetic column's compute(). ` +
+                        `Synthetic columns may only reference real or override columns.`);
+                }
+                return smart.getValue(innerCol);
+            };
+            return String(await syntheticDef.compute(guardedRow));
+        }
+        const idx = map.get(colName);
+        if (idx === undefined) {
+            throw new Error((0, stringUtils_1.buildColumnNotFoundError)(colName, [...map.keys(), ...Object.keys((_b = config.syntheticColumns) !== null && _b !== void 0 ? _b : {})]));
+        }
+        const columnOverride = (_c = config.columnOverrides) === null || _c === void 0 ? void 0 : _c[colName];
+        const cell = config.strategies.getCellLocator
+            ? config.strategies.getCellLocator({
+                row: rowLocator, root: rootLocator, columnName: colName,
+                columnIndex: idx, rowIndex, page: rootLocator.page(), config,
+            })
+            : resolve(config.cellSelector, rowLocator).nth(idx);
+        if (columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.read) {
+            const getCell = (name) => {
+                const ci = map.get(name);
+                if (ci === undefined)
+                    throw new Error(`Column "${name}" not found`);
+                return resolve(config.cellSelector, rowLocator).nth(ci);
+            };
+            return String(await columnOverride.read(cell, { row: smart, columnName: colName, columnIndex: idx, getCell }));
+        }
+        return (await cell.innerText()).trim();
+    };
     smart.toJSON = async (options) => {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        // Atomic mode: snapshot the row in a single evaluate, then apply column overrides
+        // against a frozen reconstruction. Zero inter-column stagger — even in-place React
+        // re-renders can't affect it because overrides read from a detached clone.
+        if (options === null || options === void 0 ? void 0 : options.atomic) {
+            const cellSel = config.cellSelector;
+            if (typeof cellSel !== 'string') {
+                throw new Error('[SmartTable] toJSON({ atomic: true }) requires cellSelector to be a CSS string, not a function.');
+            }
+            const page = rootLocator.page();
+            // Step 1: clone row in browser memory (NOT in the DOM), extract text + row HTML.
+            // Uses textContent (not innerText) because the clone is detached — innerText
+            // falls back to textContent on detached nodes per HTML spec, so be explicit.
+            const cloneHandle = await rowLocator.evaluateHandle(el => el.cloneNode(true));
+            let snapshot;
+            try {
+                snapshot = await cloneHandle.evaluate((row, sel) => {
+                    const cells = row.querySelectorAll(sel);
+                    return {
+                        rowHTML: row.outerHTML,
+                        cells: [...cells].map(c => ({
+                            text: (c.textContent || '').trim(),
+                        })),
+                    };
+                }, cellSel);
+            }
+            finally {
+                await cloneHandle.dispose();
+            }
+            // Determine which columns have overrides (need lazy materialization)
+            const columnsToProcess = [...map.entries()]
+                .filter(([col]) => !(options === null || options === void 0 ? void 0 : options.columns) || options.columns.includes(col));
+            const hasAnyOverride = columnsToProcess.some(([col]) => { var _a, _b; return !!((_b = (_a = config.columnOverrides) === null || _a === void 0 ? void 0 : _a[col]) === null || _b === void 0 ? void 0 : _b.read); });
+            // Step 2: lazily materialize the row if any override needs a Locator.
+            // Uses position:fixed off-screen (NOT display:none — that breaks innerText).
+            const snapId = `__st_snap_${Math.random().toString(36).slice(2, 10)}`;
+            let materialized = false;
+            const materializeRow = async () => {
+                if (materialized)
+                    return;
+                await page.evaluate(([html, id]) => {
+                    const c = document.createElement('div');
+                    c.id = id;
+                    c.style.cssText = 'position:fixed;left:-99999px;top:-99999px;opacity:0;pointer-events:none';
+                    // Wrap in <table><tbody> so the browser's HTML parser keeps <tr>/<td> intact.
+                    c.innerHTML = `<table><tbody>${html}</tbody></table>`;
+                    document.body.appendChild(c);
+                }, [snapshot.rowHTML, snapId]);
+                materialized = true;
+            };
+            const cleanupSnapshot = async () => {
+                if (!materialized)
+                    return;
+                await page.evaluate(id => { var _a; return (_a = document.getElementById(id)) === null || _a === void 0 ? void 0 : _a.remove(); }, snapId);
+            };
+            // Step 3: build getCell helper — returns Locator to cell in materialized row
+            const getCell = (colName) => {
+                const colIdx = map.get(colName);
+                if (colIdx === undefined)
+                    throw new Error(`[SmartTable] getCell: column "${colName}" not found`);
+                return page.locator(`#${snapId}`).locator(cellSel).nth(colIdx);
+            };
+            try {
+                if (hasAnyOverride)
+                    await materializeRow();
+                const result = {};
+                for (const [col, idx] of columnsToProcess) {
+                    const columnOverride = (_a = config.columnOverrides) === null || _a === void 0 ? void 0 : _a[col];
+                    const mapper = columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.read;
+                    if (mapper) {
+                        const cell = page.locator(`#${snapId}`).locator(cellSel).nth(idx);
+                        try {
+                            result[col] = await mapper(cell, { row: smart, columnName: col, columnIndex: idx, getCell });
+                        }
+                        catch (err) {
+                            const wrapped = new Error(`[SmartTable] toJSON({ atomic: true }): column override for "${col}" failed — ${err.message}`);
+                            wrapped.cause = err;
+                            throw wrapped;
+                        }
+                    }
+                    else if (idx < snapshot.cells.length) {
+                        result[col] = snapshot.cells[idx].text;
+                    }
+                }
+                for (const [name, def] of Object.entries((_b = config.syntheticColumns) !== null && _b !== void 0 ? _b : {})) {
+                    if ((options === null || options === void 0 ? void 0 : options.columns) && !options.columns.includes(name))
+                        continue;
+                    const snapshotRow = Object.create(smart);
+                    snapshotRow.getValue = async (col) => {
+                        if (col in result)
+                            return String(result[col]);
+                        return smart.getValue(col);
+                    };
+                    result[name] = String(await def.compute(snapshotRow));
+                }
+                return result;
+            }
+            finally {
+                await cleanupSnapshot();
+            }
+        }
         const result = {};
         const page = rootLocator.page();
         // Build a getHeaderCell helper for the beforeCellRead context.
@@ -427,17 +537,82 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                     throw new Error(`Column "${colName}" not found`);
                 return resolve(config.headerSelector, rootLocator).nth(idx);
             };
+        // #366 / #392: on virtualized tables the row's DOM node can recycle between the
+        // per-column awaits below. When a self-healing locator is in use (the row locator was
+        // rebuilt with a CSS selector, e.g. `[data-rowindex="47"]`), the locator automatically
+        // re-queries the DOM — no rescan needed. For plain-number strategies (JS-only, no
+        // selector), fall back to the original rescan-then-scrollToRow approach.
+        const resolveRI = config.strategies.resolveRowIndex;
+        const canPin = !!resolveRI && typeof rowIndex === 'number';
+        const isSelfHealing = smart._selfHealing === true;
+        const stableCtx = { root: rootLocator, config, page, resolve };
+        const inBatch = smart._inBatch === true || !!smart._barrier;
+        let lastGood = rowLocator;
+        const resolveStableRow = async () => {
+            var _a;
+            // Self-healing locator: always re-queries the DOM by attribute — no rescan needed.
+            if (isSelfHealing)
+                return rowLocator;
+            if (!canPin)
+                return rowLocator;
+            const result = await resolveRI(lastGood);
+            const resolvedIndex = result !== undefined ? (0, rowResolution_1.normalizeRowIndexResult)(result).index : undefined;
+            if (resolvedIndex === rowIndex)
+                return lastGood; // still correct
+            // Drifted (recycled). Re-locate the row carrying the expected logical index.
+            const rescan = async () => {
+                const rows = await resolve(config.rowSelector, rootLocator).all();
+                for (const r of rows) {
+                    const rResult = await resolveRI(r);
+                    if (rResult !== undefined && (0, rowResolution_1.normalizeRowIndexResult)(rResult).index === rowIndex)
+                        return r;
+                }
+                return null;
+            };
+            let recovered = await rescan();
+            if (!recovered && !inBatch && ((_a = config.strategies.viewport) === null || _a === void 0 ? void 0 : _a.scrollToRow)) {
+                await config.strategies.viewport.scrollToRow(stableCtx, rowIndex);
+                recovered = await rescan();
+            }
+            if (!recovered) {
+                throw new Error(`[SmartTable] toJSON: row ${rowIndex} recycled out of the DOM mid-read and could not be recovered — ` +
+                    `the returned object would mix fields from different rows. ` +
+                    (inBatch
+                        ? `(During a map/forEach batch, scroll-back recovery is disabled to avoid disrupting sibling rows; the row must stay mounted for the read.)`
+                        : `Ensure a viewport.scrollToRow can restore the row.`));
+            }
+            lastGood = recovered;
+            return recovered;
+        };
+        // getCell for non-atomic mode: returns a live cell Locator via the column map.
+        // Uses the last-known-good row from the re-pin so it's as fresh as possible,
+        // but returns raw cell Locators, not override-processed values.
+        const getCellLive = (colName) => {
+            const colIdx = map.get(colName);
+            if (colIdx === undefined)
+                throw new Error(`[SmartTable] getCell: column "${colName}" not found`);
+            const row = lastGood;
+            if (config.strategies.getCellLocator) {
+                return config.strategies.getCellLocator({
+                    row, root: rootLocator, columnName: colName,
+                    columnIndex: colIdx, rowIndex, page, config,
+                });
+            }
+            return resolve(config.cellSelector, row).nth(colIdx);
+        };
         for (const [col, idx] of map.entries()) {
             if ((options === null || options === void 0 ? void 0 : options.columns) && !options.columns.includes(col)) {
                 continue;
             }
+            // Re-pin to the correct logical row before reading this column (#366).
+            const stableRow = await resolveStableRow();
             // Check if we have a column override for this column
-            const columnOverride = (_a = config.columnOverrides) === null || _a === void 0 ? void 0 : _a[col];
+            const columnOverride = (_c = config.columnOverrides) === null || _c === void 0 ? void 0 : _c[col];
             const mapper = columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.read;
             // --- Navigation Logic Start ---
             const cell = config.strategies.getCellLocator
                 ? config.strategies.getCellLocator({
-                    row: rowLocator,
+                    row: stableRow,
                     root: rootLocator,
                     columnName: col,
                     columnIndex: idx,
@@ -445,7 +620,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                     page: page,
                     config
                 })
-                : resolve(config.cellSelector, rowLocator).nth(idx);
+                : resolve(config.cellSelector, stableRow).nth(idx);
             let targetCell = cell;
             // Always call _navigateToCell to ensure Lock-Step synchronization
             // even if the cell is already present (it handles check-in inside)
@@ -457,7 +632,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 getHeaders: table === null || table === void 0 ? void 0 : table.getHeaders,
                 column: col,
                 index: idx,
-                rowLocator,
+                rowLocator: stableRow,
                 rowIndex,
                 barrier: smart._barrier
             });
@@ -472,20 +647,20 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                     cell: targetCell,
                     columnName: col,
                     columnIndex: idx,
-                    row: rowLocator,
+                    row: stableRow,
                     page,
                     root: rootLocator,
                     getHeaderCell,
                 });
             }
             // Cell loading wait (if configured)
-            const isCellLoading = (_b = config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isCellLoading;
-            const rawCellTimeout = (_c = config.strategies.loading) === null || _c === void 0 ? void 0 : _c.cellLoadingTimeout;
+            const isCellLoading = (_d = config.strategies.loading) === null || _d === void 0 ? void 0 : _d.isCellLoading;
+            const rawCellTimeout = (_e = config.strategies.loading) === null || _e === void 0 ? void 0 : _e.cellLoadingTimeout;
             // undefined = unset (read as-is immediately); 0 = no wait (immediate check); >0 = wait up to N ms
             const cellLoadingTimeout = rawCellTimeout !== undefined && Number.isFinite(rawCellTimeout) && rawCellTimeout >= 0
                 ? rawCellTimeout
                 : undefined;
-            const onCellLoadingTimeout = (_e = (_d = config.strategies.loading) === null || _d === void 0 ? void 0 : _d.onCellLoadingTimeout) !== null && _e !== void 0 ? _e : 'read-as-is';
+            const onCellLoadingTimeout = (_g = (_f = config.strategies.loading) === null || _f === void 0 ? void 0 : _f.onCellLoadingTimeout) !== null && _g !== void 0 ? _g : 'read-as-is';
             if (isCellLoading && await isCellLoading(targetCell, col, smart)) {
                 if (cellLoadingTimeout !== undefined) {
                     (0, debugUtils_1.logDebug)(config, 'verbose', `toJSON: cell "${col}" — waiting up to ${cellLoadingTimeout}ms`);
@@ -515,7 +690,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             }
             if (mapper) {
                 // Apply mapper
-                const mappedValue = await mapper(targetCell);
+                const mappedValue = await mapper(targetCell, { row: smart, columnName: col, columnIndex: idx, getCell: getCellLive });
                 result[col] = mappedValue;
             }
             else {
@@ -524,17 +699,31 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 result[col] = (text || '').trim();
             }
         }
+        for (const [name, def] of Object.entries((_h = config.syntheticColumns) !== null && _h !== void 0 ? _h : {})) {
+            if ((options === null || options === void 0 ? void 0 : options.columns) && !options.columns.includes(name))
+                continue;
+            const snapshotRow = Object.create(smart);
+            snapshotRow.getValue = async (col) => {
+                if (col in result)
+                    return String(result[col]);
+                return smart.getValue(col);
+            };
+            result[name] = String(await def.compute(snapshotRow));
+        }
         return result;
     };
     smart.smartFill = async (data, fillOptions) => {
-        var _a;
+        var _a, _b, _c;
         (0, debugUtils_1.logDebug)(config, 'info', 'Filling row', data);
         for (const [colName, value] of Object.entries(data)) {
             if (value === undefined)
                 continue;
+            if ((_a = config.syntheticColumns) === null || _a === void 0 ? void 0 : _a[colName]) {
+                throw new Error(`Cannot fill synthetic column "${colName}" — it has no DOM cell`);
+            }
             const colIdx = map.get(colName);
             if (colIdx === undefined) {
-                throw new Error((0, stringUtils_1.buildColumnNotFoundError)(colName, Array.from(map.keys())));
+                throw new Error((0, stringUtils_1.buildColumnNotFoundError)(colName, [...map.keys(), ...Object.keys((_b = config.syntheticColumns) !== null && _b !== void 0 ? _b : {})]));
             }
             await _navigateToCell({
                 config,
@@ -548,12 +737,15 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 rowIndex,
                 barrier: smart._barrier
             });
-            const columnOverride = (_a = config.columnOverrides) === null || _a === void 0 ? void 0 : _a[colName];
+            const columnOverride = (_c = config.columnOverrides) === null || _c === void 0 ? void 0 : _c[colName];
             if (columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.write) {
                 const cellLocator = smart.getCell(colName);
                 let currentValue;
                 if (columnOverride.read) {
-                    currentValue = await columnOverride.read(cellLocator);
+                    currentValue = await columnOverride.read(cellLocator, {
+                        row: smart, columnName: colName, columnIndex: colIdx,
+                        getCell: (name) => smart.getCell(name),
+                    });
                 }
                 await columnOverride.write({
                     cell: cellLocator,

package/dist/strategies/fill.js

@@ -14,7 +14,11 @@ exports.FillStrategies = {
             let currentValue;
             // Auto-sync: If read exists, get current state first
             if (columnOverride.read) {
-                currentValue = await columnOverride.read(cell);
+                const columnIndex = table ? (await table.getHeaders()).indexOf(columnName) : -1;
+                currentValue = await columnOverride.read(cell, {
+                    row, columnName, columnIndex,
+                    getCell: (name) => row.getCell(name),
+                });
             }
             await columnOverride.write({
                 cell,
@@ -69,7 +73,6 @@ exports.FillStrategies = {
         const inputTag = await inputLocator.evaluate((el) => el.tagName.toLowerCase()).catch(() => 'unknown');
         const inputType = await inputLocator.getAttribute('type').catch(() => null);
         const isContentEditable = await inputLocator.getAttribute('contenteditable').catch(() => null);
-        // console.log(`[SmartTable] Filling "${columnName}" with value "${value}" (input: ${inputTag}, type: ${inputType})`);
         if (inputType === 'checkbox' || inputType === 'radio') {
             // Boolean value for checkbox/radio
             const shouldBeChecked = Boolean(value);

package/dist/strategies/headers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HeaderStrategies = void 0;
+const debugUtils_1 = require("../utils/debugUtils");
 exports.HeaderStrategies = {
     /**
      * Default strategy: Returns only the headers currently visible in the DOM.
@@ -70,10 +71,12 @@ exports.HeaderStrategies = {
                 }
             }
             else {
-                console.warn("HeaderStrategies.horizontalScroll: Could not find scroller. Returning visible headers.");
+                (0, debugUtils_1.logDebug)(config, 'info', "HeaderStrategies.horizontalScroll: Could not find scroller. Returning visible headers.");
+            }
+            if (isScrollerFound) {
+                await scrollerHandle.evaluate(el => el.scrollLeft = 0);
+                await page.waitForTimeout(200);
             }
-            await scrollerHandle.evaluate(el => el.scrollLeft = 0);
-            await page.waitForTimeout(200);
             return Array.from(collectedHeaders);
         };
     }

package/dist/strategies/viewport.js

@@ -46,16 +46,59 @@ const dataAttribute = (options) => {
                 return { first: Math.min(...indices), last: Math.max(...indices) };
             }, { rowSel, cellSel, colAttr, colOffset });
         },
+        getVisibleRowIndices: async ({ root, config }) => {
+            const rowSel = config.rowSelector;
+            // Geometry-based (mirrors getVisibleRowRange's inclusive intersection), but returns
+            // the rows' DOM positions so the iteration engine can drop overscan rows (#353/#357).
+            return root.evaluate((el, { rowSel, containerSel }) => {
+                const rows = Array.from(el.querySelectorAll(rowSel));
+                const container = el.closest(containerSel);
+                const containerRect = container ? container.getBoundingClientRect() : null;
+                const visible = [];
+                rows.forEach((r, i) => {
+                    // Container not resolvable — can't measure, so keep every row (no filtering).
+                    if (!containerRect) {
+                        visible.push(i);
+                        return;
+                    }
+                    const rect = r.getBoundingClientRect();
+                    if (rect.height === 0)
+                        return; // unrendered / detached
+                    if (rect.bottom > containerRect.top && rect.top < containerRect.bottom)
+                        visible.push(i);
+                });
+                return visible;
+            }, { rowSel, containerSel });
+        },
         getVisibleRowRange: async ({ root, config }) => {
             const rowSel = config.rowSelector;
-            return root.evaluate((el, { rowSel, rowAttr, rowOffset }) => {
-                const indices = Array.from(el.querySelectorAll(rowSel))
+            return root.evaluate((el, { rowSel, rowAttr, rowOffset, containerSel }) => {
+                const rows = Array.from(el.querySelectorAll(rowSel));
+                // #353: report only rows actually within the scroll container's vertical
+                // bounds, not every mounted row. Previously overscan rows (kept mounted by
+                // the virtual scroller above/below the fold) were counted as "visible".
+                // Inclusive: a row with ANY vertical overlap counts as visible; only rows
+                // entirely above or below the container are dropped — so we never drop a
+                // partially-visible real row.
+                const container = el.closest(containerSel);
+                const containerRect = container ? container.getBoundingClientRect() : null;
+                const indices = rows
+                    .filter(r => {
+                    // Container not resolvable — can't measure, so keep all rows (safe
+                    // fallback, preserves pre-#353 behavior rather than risk dropping real rows).
+                    if (!containerRect)
+                        return true;
+                    const rect = r.getBoundingClientRect();
+                    if (rect.height === 0)
+                        return false; // unrendered / detached
+                    return rect.bottom > containerRect.top && rect.top < containerRect.bottom;
+                })
                     .map(r => Number(r.getAttribute(rowAttr)) - rowOffset)
                     .filter(n => !isNaN(n));
                 if (!indices.length)
                     return { first: 0, last: 0 };
                 return { first: Math.min(...indices), last: Math.max(...indices) };
-            }, { rowSel, rowAttr, rowOffset });
+            }, { rowSel, rowAttr, rowOffset, containerSel });
         },
         scrollToColumn: async ({ root, config }, colIndex) => {
             const headerSel = typeof config.headerSelector === 'string' ? config.headerSelector : null;