@rickcedwhat/playwright-smart-table 6.19.0 → 6.20.1-next.19d3cd3

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,45 @@ 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, _f;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         // 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.
@@ -424,10 +434,84 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 throw new Error('[SmartTable] toJSON({ atomic: true }) requires cellSelector to be a CSS string, not a function.');
             }
             const page = rootLocator.page();
+            // Re-pin: the row locator is a positional nth-child from the iteration loop.
+            // On recycling virtualizers, elements can shift between SmartRow creation and
+            // this clone — the nth element may now show a different row's content.
+            // Verify via resolveRowIndex and rescan if drifted.
+            let cloneTarget = rowLocator;
+            const resolveRI = config.strategies.resolveRowIndex;
+            const isSelfHealing = smart._selfHealing === true;
+            const rescanForRow = resolveRI && typeof rowIndex === 'number' && !isSelfHealing
+                ? async () => {
+                    const rows = await resolve(config.rowSelector, rootLocator).all();
+                    for (const r of rows) {
+                        try {
+                            const rResult = await resolveRI(r);
+                            if (rResult !== undefined && (0, rowResolution_1.normalizeRowIndexResult)(rResult).index === rowIndex)
+                                return r;
+                        }
+                        catch ( /* element may have detached during scan */_a) { /* element may have detached during scan */ }
+                    }
+                    return null;
+                }
+                : null;
+            if (rescanForRow) {
+                let drifted = false;
+                try {
+                    const curResult = await resolveRI(rowLocator);
+                    const curIndex = curResult !== undefined
+                        ? (0, rowResolution_1.normalizeRowIndexResult)(curResult).index
+                        : undefined;
+                    drifted = curIndex !== rowIndex;
+                }
+                catch (_k) {
+                    drifted = true;
+                }
+                if (drifted) {
+                    const inBatch = smart._inBatch === true || !!smart._barrier;
+                    let recovered = await rescanForRow();
+                    if (!recovered && !inBatch && ((_a = config.strategies.viewport) === null || _a === void 0 ? void 0 : _a.scrollToRow)) {
+                        await config.strategies.viewport.scrollToRow({ root: rootLocator, config, page, resolve }, rowIndex);
+                        const deadline = Date.now() + 500;
+                        while (!recovered && Date.now() < deadline) {
+                            recovered = await rescanForRow();
+                            if (!recovered)
+                                await page.waitForTimeout(50);
+                        }
+                    }
+                    if (!recovered) {
+                        throw new Error(`[SmartTable] toJSON({ atomic: true }): row ${rowIndex} recycled out of the DOM and could not be recovered. ` +
+                            (inBatch
+                                ? `(During a map/forEach batch, scroll-back recovery is disabled to avoid disrupting sibling rows.)`
+                                : `Ensure a viewport.scrollToRow strategy can restore the row.`));
+                    }
+                    cloneTarget = recovered;
+                }
+            }
+            // Wait for async content renders to settle before cloning.
+            if (config.strategies.contentReady) {
+                await config.strategies.contentReady(cloneTarget, page);
+                // Revalidate: the element may have recycled during the await.
+                if (rescanForRow) {
+                    let postIdx;
+                    try {
+                        const r = await resolveRI(cloneTarget);
+                        postIdx = r !== undefined ? (0, rowResolution_1.normalizeRowIndexResult)(r).index : undefined;
+                    }
+                    catch (_l) {
+                        postIdx = undefined;
+                    }
+                    if (postIdx !== rowIndex) {
+                        const reFound = await rescanForRow();
+                        if (reFound)
+                            cloneTarget = reFound;
+                    }
+                }
+            }
             // 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));
+            const cloneHandle = await cloneTarget.evaluateHandle(el => el.cloneNode(true));
             let snapshot;
             try {
                 snapshot = await cloneHandle.evaluate((row, sel) => {
@@ -481,7 +565,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                     await materializeRow();
                 const result = {};
                 for (const [col, idx] of columnsToProcess) {
-                    const columnOverride = (_a = config.columnOverrides) === null || _a === void 0 ? void 0 : _a[col];
+                    const columnOverride = (_b = config.columnOverrides) === null || _b === void 0 ? void 0 : _b[col];
                     const mapper = columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.read;
                     if (mapper) {
                         const cell = page.locator(`#${snapId}`).locator(cellSel).nth(idx);
@@ -498,6 +582,17 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                         result[col] = snapshot.cells[idx].text;
                     }
                 }
+                for (const [name, def] of Object.entries((_c = config.syntheticColumns) !== null && _c !== void 0 ? _c : {})) {
+                    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 {
@@ -516,43 +611,39 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                     throw new Error(`Column "${colName}" not found`);
                 return resolve(config.headerSelector, rootLocator).nth(idx);
             };
-        // #366: on virtualized tables the row's DOM node can recycle between the per-column
-        // awaits below, which would make one toJSON() mix fields from different logical rows.
-        // When a resolveRowIndex strategy is configured and this row has a known logical index,
-        // re-pin the row before each column read: if the current locator has drifted to a
-        // different logical row, re-locate the correct one (rescan, then scrollToRow) — or throw,
-        // rather than silently returning a mixed-row object. No-op without resolveRowIndex/rowIndex.
+        // #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 };
-        // scrollToRow recovery is only safe for standalone reads (findRow/findRowByIndex/getRow*).
-        // Inside a map/forEach/filter or async-iterator batch, the other rows are positional
-        // locators from one DOM snapshot (and, in synchronized mode, coordinated by a barrier),
-        // so an independent scroll here would fight peers / invalidate their locators. In a batch
-        // we recover by rescanning the currently-mounted rows only, and throw if that fails.
         const inBatch = smart._inBatch === true || !!smart._barrier;
-        // The last locator we confirmed points at the expected logical row. After a recovery the
-        // node the original `rowLocator` referenced stays drifted, so re-checking it every column
-        // would re-run the full rescan needlessly; validate the last-known-good locator first and
-        // only fall back to a rescan when it too has drifted.
         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;
-            if ((await resolveRI(lastGood)) === rowIndex)
+            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) {
-                    if ((await resolveRI(r)) === rowIndex)
+                    const rResult = await resolveRI(r);
+                    if (rResult !== undefined && (0, rowResolution_1.normalizeRowIndexResult)(rResult).index === rowIndex)
                         return r;
                 }
                 return null;
             };
             let recovered = await rescan();
-            // Scroll the row back only when it's safe to move the viewport (not mid-batch).
             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();
@@ -590,7 +681,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             // 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 = (_b = config.columnOverrides) === null || _b === void 0 ? void 0 : _b[col];
+            const columnOverride = (_d = config.columnOverrides) === null || _d === void 0 ? void 0 : _d[col];
             const mapper = columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.read;
             // --- Navigation Logic Start ---
             const cell = config.strategies.getCellLocator
@@ -637,13 +728,13 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 });
             }
             // Cell loading wait (if configured)
-            const isCellLoading = (_c = config.strategies.loading) === null || _c === void 0 ? void 0 : _c.isCellLoading;
-            const rawCellTimeout = (_d = config.strategies.loading) === null || _d === void 0 ? void 0 : _d.cellLoadingTimeout;
+            const isCellLoading = (_e = config.strategies.loading) === null || _e === void 0 ? void 0 : _e.isCellLoading;
+            const rawCellTimeout = (_f = config.strategies.loading) === null || _f === void 0 ? void 0 : _f.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 = (_f = (_e = config.strategies.loading) === null || _e === void 0 ? void 0 : _e.onCellLoadingTimeout) !== null && _f !== void 0 ? _f : 'read-as-is';
+            const onCellLoadingTimeout = (_h = (_g = config.strategies.loading) === null || _g === void 0 ? void 0 : _g.onCellLoadingTimeout) !== null && _h !== void 0 ? _h : '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`);
@@ -682,17 +773,31 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 result[col] = (text || '').trim();
             }
         }
+        for (const [name, def] of Object.entries((_j = config.syntheticColumns) !== null && _j !== void 0 ? _j : {})) {
+            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,
@@ -706,7 +811,7 @@ 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;

package/dist/strategies/contentReady.d.ts

@@ -0,0 +1,13 @@
+import type { ContentReadyStrategy } from '../types';
+export type { ContentReadyStrategy };
+export declare const ContentReadyStrategies: {
+    /**
+     * Polls the row's text content until two consecutive reads match.
+     * Handles recycling virtualizers where position updates synchronously
+     * but React renders cell content asynchronously.
+     */
+    textStable: (options?: {
+        timeout?: number;
+        interval?: number;
+    }) => ContentReadyStrategy;
+};

package/dist/strategies/contentReady.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentReadyStrategies = void 0;
+exports.ContentReadyStrategies = {
+    /**
+     * Polls the row's text content until two consecutive reads match.
+     * Handles recycling virtualizers where position updates synchronously
+     * but React renders cell content asynchronously.
+     */
+    textStable: (options = {}) => {
+        var _a, _b;
+        const timeout = (_a = options.timeout) !== null && _a !== void 0 ? _a : 500;
+        const interval = (_b = options.interval) !== null && _b !== void 0 ? _b : 50;
+        return async (row, page) => {
+            const deadline = Date.now() + timeout;
+            const remaining = () => Math.max(0, deadline - Date.now());
+            let prev = await row.innerText({ timeout: remaining() || timeout });
+            while (remaining() > 0) {
+                await page.waitForTimeout(Math.min(interval, remaining()));
+                if (remaining() <= 0)
+                    break;
+                const cur = await row.innerText({ timeout: remaining() });
+                if (cur === prev)
+                    return;
+                prev = cur;
+            }
+        };
+    },
+};

package/dist/strategies/fill.js

@@ -73,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/index.d.ts

@@ -9,6 +9,7 @@ export * from './loading';
 export * from './stabilization';
 export * from './filter';
 export * from './viewport';
+export * from './contentReady';
 export declare const Strategies: {
     Pagination: {
         click: (selectors: {
@@ -100,4 +101,10 @@ export declare const Strategies: {
     Viewport: {
         dataAttribute: (options?: import("./viewport").DataAttributeViewportOptions) => import("../types").ViewportStrategy;
     };
+    ContentReady: {
+        textStable: (options?: {
+            timeout?: number;
+            interval?: number;
+        }) => import("./contentReady").ContentReadyStrategy;
+    };
 };

package/dist/strategies/index.js

@@ -26,6 +26,7 @@ const loading_1 = require("./loading");
 const stabilization_1 = require("./stabilization");
 const filter_1 = require("./filter");
 const viewport_1 = require("./viewport");
+const contentReady_1 = require("./contentReady");
 __exportStar(require("./pagination"), exports);
 __exportStar(require("./sorting"), exports);
 __exportStar(require("./columns"), exports);
@@ -37,6 +38,7 @@ __exportStar(require("./loading"), exports);
 __exportStar(require("./stabilization"), exports);
 __exportStar(require("./filter"), exports);
 __exportStar(require("./viewport"), exports);
+__exportStar(require("./contentReady"), exports);
 exports.Strategies = {
     Pagination: pagination_1.PaginationStrategies,
     Sorting: sorting_1.SortingStrategies,
@@ -49,4 +51,5 @@ exports.Strategies = {
     Stabilization: stabilization_1.StabilizationStrategies,
     Filter: filter_1.FilterStrategies,
     Viewport: viewport_1.ViewportStrategies,
+    ContentReady: contentReady_1.ContentReadyStrategies,
 };

package/dist/strategies/pagination.js

@@ -83,6 +83,7 @@ exports.PaginationStrategies = {
                 const scrollTarget = options.scrollTarget
                     ? resolve(options.scrollTarget, root)
                     : root;
+                const beforeScrollTop = await scrollTarget.evaluate((el) => el.scrollTop);
                 const doScroll = async () => {
                     const box = await scrollTarget.boundingBox();
                     const scrollValue = amount * directionMultiplier;
@@ -98,8 +99,16 @@ exports.PaginationStrategies = {
                         await page.mouse.wheel(0, scrollValue);
                     }
                 };
-                // Stabilization: Wait
-                return await stabilization(context, doScroll);
+                // Stabilization: Wait for content to settle
+                const stabilizationResult = await stabilization(context, doScroll);
+                // EOF detection: use scroll position, not stabilization result.
+                // Stabilization may time out for recycling virtualizers when the scroll
+                // amount is small enough to stay within the overscan window (no new rows
+                // rendered), but the scroll position still changed — we haven't reached
+                // the end of the data.
+                const afterScrollTop = await scrollTarget.evaluate((el) => el.scrollTop);
+                const scrollMoved = Math.abs(afterScrollTop - beforeScrollTop) >= 1;
+                return scrollMoved || stabilizationResult;
             };
         };
         const createGoToFirst = () => {

package/dist/strategies/viewport.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ViewportStrategies = void 0;
+const debugUtils_1 = require("../utils/debugUtils");
 /**
  * Viewport strategies for tables where row and cell elements carry a DOM attribute
  * equal to their index (e.g. Braintrust logs table, TanStack-style grids).
@@ -11,6 +12,10 @@ exports.ViewportStrategies = void 0;
  *   - scrollToColumn       — aligns header's left edge to container left, waits for cell mount
  *   - scrollToRow          — scrolls row into view, waits for row mount
  *
+ * **Important:** `rowAttribute` must be present on the elements matched by `rowSelector`,
+ * not on child cells. If row elements lack the attribute, `getVisibleRowRange` returns
+ * `{first:0, last:0}` and logs a warning at the `error` log level.
+ *
  * @example
  * // TanStack / Braintrust (data-index, 0-based — default)
  * viewport: Strategies.Viewport.dataAttribute()
@@ -34,17 +39,22 @@ const dataAttribute = (options) => {
         getVisibleColumnRange: async ({ root, config }) => {
             const rowSel = config.rowSelector;
             const cellSel = typeof config.cellSelector === 'string' ? config.cellSelector : `[${colAttr}]`;
-            return root.evaluate((el, { rowSel, cellSel, colAttr, colOffset }) => {
+            const result = await root.evaluate((el, { rowSel, cellSel, colAttr, colOffset }) => {
                 const firstRow = el.querySelector(rowSel);
                 if (!firstRow)
-                    return { first: 0, last: 0 };
-                const indices = Array.from(firstRow.querySelectorAll(cellSel))
+                    return { first: 0, last: 0, _cellCount: 0, _validCount: 0 };
+                const cells = Array.from(firstRow.querySelectorAll(cellSel));
+                const indices = cells
                     .map(c => Number(c.getAttribute(colAttr)) - colOffset)
                     .filter(n => !isNaN(n));
                 if (!indices.length)
-                    return { first: 0, last: 0 };
-                return { first: Math.min(...indices), last: Math.max(...indices) };
+                    return { first: 0, last: 0, _cellCount: cells.length, _validCount: 0 };
+                return { first: Math.min(...indices), last: Math.max(...indices), _cellCount: cells.length, _validCount: indices.length };
             }, { rowSel, cellSel, colAttr, colOffset });
+            if (result._cellCount > 0 && result._validCount === 0) {
+                (0, debugUtils_1.logDebug)(config, 'error', `dataAttribute viewport: ${result._cellCount} cell(s) found but none have attribute "${colAttr}". Check that columnAttribute targets cell elements matched by cellSelector.`);
+            }
+            return { first: result.first, last: result.last };
         },
         getVisibleRowIndices: async ({ root, config }) => {
             const rowSel = config.rowSelector;
@@ -72,33 +82,30 @@ const dataAttribute = (options) => {
         },
         getVisibleRowRange: async ({ root, config }) => {
             const rowSel = config.rowSelector;
-            return root.evaluate((el, { rowSel, rowAttr, rowOffset, containerSel }) => {
+            const result = await 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
+                const visibleRows = 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 false;
                     return rect.bottom > containerRect.top && rect.top < containerRect.bottom;
-                })
+                });
+                const indices = visibleRows
                     .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) };
+                    return { first: 0, last: 0, _rowCount: visibleRows.length, _validCount: 0 };
+                return { first: Math.min(...indices), last: Math.max(...indices), _rowCount: visibleRows.length, _validCount: indices.length };
             }, { rowSel, rowAttr, rowOffset, containerSel });
+            if (result._rowCount > 0 && result._validCount === 0) {
+                (0, debugUtils_1.logDebug)(config, 'error', `dataAttribute viewport: ${result._rowCount} row(s) found but none have attribute "${rowAttr}". Check that rowAttribute targets row elements matched by rowSelector, not child cells. getVisibleRowRange returning {first:0, last:0}.`);
+            }
+            return { first: result.first, last: result.last };
         },
         scrollToColumn: async ({ root, config }, colIndex) => {
             const headerSel = typeof config.headerSelector === 'string' ? config.headerSelector : null;