@rickcedwhat/playwright-smart-table 6.25.0-next.c81cb3d → 6.25.0-next.d8860d0

package/dist/engine/cellNavigation.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.navigateToCell = void 0;
 const rowResolution_1 = require("./rowResolution");
 const debugUtils_1 = require("../utils/debugUtils");
+const memoizeViewport_1 = require("../utils/memoizeViewport");
 const log = (config, msg) => (0, debugUtils_1.logDebug)(config, 'verbose', msg);
 /**
  * Navigates to a cell with active cell optimization.
@@ -49,9 +50,9 @@ const navigateToCell = async (params) => {
     };
     // Viewport-oracle phase: direct positioning for 2D virtualized tables.
     // Runs before navigation primitives; falls through to them if cell still not accessible.
-    const viewport = config.strategies.viewport;
-    if (viewport && typeof rowIndex === 'number') {
-        const viaViewport = await navigateViaViewport(nav, viewport, rowIndex);
+    const cache = config.strategies.viewport && (0, memoizeViewport_1.memoizeViewport)(config.strategies.viewport);
+    if (cache && typeof rowIndex === 'number') {
+        const viaViewport = await navigateViaViewport(nav, cache.viewport, rowIndex, cache.clear);
         if (viaViewport)
             return viaViewport;
     }
@@ -119,7 +120,7 @@ async function readIfInView(nav, viewport, rowIndex) {
  * Viewport phase. Returns the cell locator, or null to fall through to navigation primitives
  * (only when `strategies.navigation` is configured; otherwise throws on a miss).
  */
-async function navigateViaViewport(nav, viewport, rowIndex) {
+async function navigateViaViewport(nav, viewport, rowIndex, clearCache) {
     const { config, context, index } = nav;
     const inView = await readIfInView(nav, viewport, rowIndex);
     if (inView)
@@ -135,6 +136,8 @@ async function navigateViaViewport(nav, viewport, rowIndex) {
             await viewport.scrollToColumn(context, index);
         }
     });
+    // A peer may have performed the coordinated scroll. Drop this row's pre-scroll geometry too.
+    clearCache();
     await recoverEvictedRow(nav, viewport, rowIndex);
     if (await nav.targetReached()) {
         return nav.getCellLocator();

package/dist/engine/countRows.d.ts

@@ -24,4 +24,5 @@ export interface CountRowsEnv<T = any> {
 export declare function countRows<T>(env: CountRowsEnv<T>, filters?: Record<string, FilterValue>, options?: {
     exact?: boolean;
     maxPages?: number;
+    signal?: AbortSignal;
 }): Promise<number>;

package/dist/engine/countRows.js

@@ -40,15 +40,15 @@ function requireMap(tableMapper) {
  * Callers must have initialized the table.
  */
 async function countRows(env, filters, options) {
-    var _a;
-    var _b, _c;
+    var _a, _b, _c, _d, _e;
+    var _f, _g;
     const { config, rootLocator, tableMapper, rowFinder } = env;
     const filtersRecord = filters !== null && filters !== void 0 ? filters : {};
     const hasFilters = Object.keys(filtersRecord).length > 0;
-    const effectiveMaxPages = (_b = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _b !== void 0 ? _b : config.maxPages;
+    const effectiveMaxPages = (_f = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _f !== void 0 ? _f : config.maxPages;
     const pag = config.strategies.pagination;
     const hasPagination = effectiveMaxPages > 1 && !!((pag === null || pag === void 0 ? void 0 : pag.goNext) || (pag === null || pag === void 0 ? void 0 : pag.goNextBulk));
-    const exact = (_c = options === null || options === void 0 ? void 0 : options.exact) !== null && _c !== void 0 ? _c : false;
+    const exact = (_g = options === null || options === void 0 ? void 0 : options.exact) !== null && _g !== void 0 ? _g : false;
     const { domFilters, overrideFilters, syntheticFilters } = partitionFilters(config, filtersRecord);
     const hasOverrides = Object.keys(overrideFilters).length > 0;
     const hasSynthetics = Object.keys(syntheticFilters).length > 0;
@@ -80,14 +80,23 @@ async function countRows(env, filters, options) {
             return;
         await (0, loadingWait_1.waitWhileTableLoading)(config, env.getContext(), rootLocator.page(), 'countRows');
     };
+    (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
     await waitForReady();
+    (_c = options === null || options === void 0 ? void 0 : options.signal) === null || _c === void 0 ? void 0 : _c.throwIfAborted();
     const filterSuffix = hasFilters ? ` filters=${(0, safeStringify_1.safeStringify)(filtersRecord)}` : '';
     if (!hasPagination) {
         log(config, `countRows: counting rows in current viewport (no pagination)${filterSuffix}`);
-        if (!hasPostFilters)
-            return resolveRows().count();
-        const all = await resolveRows().all();
-        return countPostFilterMatches(all, all.map((_, i) => i));
+        let count;
+        if (!hasPostFilters) {
+            count = await resolveRows().count();
+        }
+        else {
+            const all = await resolveRows().all();
+            (_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.throwIfAborted();
+            count = await countPostFilterMatches(all, all.map((_, i) => i));
+        }
+        (_e = options === null || options === void 0 ? void 0 : options.signal) === null || _e === void 0 ? void 0 : _e.throwIfAborted();
+        return count;
     }
     log(config, `countRows: paginating up to ${effectiveMaxPages} page(s)${filterSuffix}`);
     const tracker = new elementTracker_1.ElementTracker('countRows');
@@ -113,6 +122,7 @@ async function countRows(env, filters, options) {
             useBulk: false,
             label: 'countRows',
             finalScanOnEof: true,
+            signal: options === null || options === void 0 ? void 0 : options.signal,
         });
         pagesScanned = scanned.pagesScanned;
     }

package/dist/engine/rowByIndex.d.ts

@@ -16,4 +16,5 @@ export interface RowByIndexEnv<T = any> {
  */
 export declare function findRowByIndex<T>(env: RowByIndexEnv<T>, index: number, options?: {
     maxPages?: number;
+    signal?: AbortSignal;
 }): Promise<SmartRow<T>>;

package/dist/engine/rowByIndex.js

@@ -11,7 +11,9 @@ const safeStringify_1 = require("../utils/safeStringify");
  * mounts (bounded by `maxPages`). Callers must have initialized the table.
  */
 async function findRowByIndex(env, index, options) {
-    var _a;
+    var _a, _b, _c, _d, _e;
+    var _f;
+    (_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.throwIfAborted();
     const { config } = env;
     (0, debugUtils_1.logDebug)(config, 'verbose', `findRowByIndex: index=${index} options=${(0, safeStringify_1.safeStringify)(options)}`);
     const resolveRI = config.strategies.resolveRowIndex;
@@ -25,9 +27,12 @@ async function findRowByIndex(env, index, options) {
     let foundSelector;
     // The currently-mounted row whose logical index === index, if any.
     const findMounted = async () => {
+        var _a, _b;
         const rows = await env.getRowLocators().all();
+        (_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.throwIfAborted();
         for (const r of rows) {
             const result = await resolveRI(r);
+            (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
             if (result === undefined)
                 continue;
             const normalized = (0, rowResolution_1.normalizeRowIndexResult)(result);
@@ -40,22 +45,25 @@ async function findRowByIndex(env, index, options) {
     };
     // 1. Already mounted (no navigation needed)?
     let loc = await findMounted();
+    (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
     // 2. Fast path: jump straight to it via the viewport's random-access scroll.
     if (!loc && (viewport === null || viewport === void 0 ? void 0 : viewport.scrollToRow)) {
         (0, debugUtils_1.logDebug)(config, 'verbose', `findRowByIndex: scrolling to row ${index}`);
         await viewport.scrollToRow(env.getContext(), index);
+        (_c = options === null || options === void 0 ? void 0 : options.signal) === null || _c === void 0 ? void 0 : _c.throwIfAborted();
         loc = await findMounted();
+        (_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.throwIfAborted();
     }
     // 3. Fallback: advance pages (on infinite-scroll tables, a "page" is a scroll step) until
     //    the row is mounted. Page 1 was already searched above.
-    const maxPages = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
+    const maxPages = (_f = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _f !== void 0 ? _f : config.maxPages;
     const scanForMounted = async () => {
         let hit = null;
         await (0, scanPages_1.scanPages)({ advancePage: env.advancePage, getCurrentPageIndex: env.getCurrentPageIndex, config }, async ({ pagesScanned }) => {
             if (pagesScanned > 1)
                 hit = await findMounted();
             return hit ? 'stop' : 'continue';
-        }, { maxPages, useBulk: false, label: 'findRowByIndex', finalScanOnEof: false });
+        }, { maxPages, useBulk: false, label: 'findRowByIndex', finalScanOnEof: false, signal: options === null || options === void 0 ? void 0 : options.signal });
         return hit;
     };
     if (!loc && config.strategies.pagination) {
@@ -66,5 +74,6 @@ async function findRowByIndex(env, index, options) {
             `Ensure a viewport.scrollToRow or pagination can bring it into view (searched up to maxPages=${maxPages}).`);
     }
     await (0, debugUtils_1.debugDelay)(config, 'findRow');
+    (_e = options === null || options === void 0 ? void 0 : options.signal) === null || _e === void 0 ? void 0 : _e.throwIfAborted();
     return env.makeSmartRow(loc, env.getMap(), index, env.getCurrentPageIndex(), foundSelector);
 }

package/dist/engine/rowFinder.d.ts

@@ -3,7 +3,7 @@ import { FinalTableConfig, Selector, SmartRow, FilterValue } from '../types';
 import { FilterEngine } from '../filterEngine';
 import { TableMapper } from './tableMapper';
 import { SmartRowArray } from '../utils/smartRowArray';
-import { NavigationBarrier } from '../utils/navigationBarrier';
+import type { NavigationBarrier } from '../utils/navigationBarrier';
 export declare class RowFinder<T = any> {
     private rootLocator;
     private config;
@@ -23,6 +23,7 @@ export declare class RowFinder<T = any> {
     findRow(filters: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
+        signal?: AbortSignal;
     }): Promise<SmartRow<T>>;
     private waitForTableReady;
     /** Unfiltered rows keep the plain `SmartRow #n` name that `_makeSmart` applies. */
@@ -31,6 +32,7 @@ export declare class RowFinder<T = any> {
         exact?: boolean;
         maxPages?: number;
         useBulkPagination?: boolean;
+        signal?: AbortSignal;
     }): Promise<SmartRowArray<T>>;
     private findRowLocator;
     private resolveRowIndex;

package/dist/engine/rowFinder.js

@@ -5,7 +5,6 @@ const debugUtils_1 = require("../utils/debugUtils");
 const smartRowArray_1 = require("../utils/smartRowArray");
 const elementTracker_1 = require("../utils/elementTracker");
 const sentinel_1 = require("../utils/sentinel");
-const navigationBarrier_1 = require("../utils/navigationBarrier");
 const rowResolution_1 = require("./rowResolution");
 const resolveCellLocator_1 = require("../utils/resolveCellLocator");
 const scanPages_1 = require("./scanPages");
@@ -172,26 +171,23 @@ class RowFinder {
                 const newIndices = await tracker.getUnseenIndices(rowLocators);
                 const currentRows = await rowLocators.all();
                 let added = 0;
-                const useBarrier = this.config.concurrency === 'synchronized' && newIndices.length > 1;
-                const barrier = useBarrier ? new navigationBarrier_1.NavigationBarrier(newIndices.length) : undefined;
                 for (const idx of newIndices) {
                     const resolved = await (0, rowResolution_1.resolveLogicalRowIndex)(currentRows[idx], this.config, () => allRows.length);
                     const rowLocator = this.nameFilteredRow(currentRows[idx], resolved, filtersRecord);
-                    const smartRow = this.makeSmartRow(rowLocator, map, resolved === null || resolved === void 0 ? void 0 : resolved.index, this.tableState.currentPageIndex, barrier, resolved === null || resolved === void 0 ? void 0 : resolved.selector);
+                    // These rows outlive the scan and may be consumed individually. Only
+                    // iteration engines that own every callback can attach a batch barrier.
+                    const smartRow = this.makeSmartRow(rowLocator, map, resolved === null || resolved === void 0 ? void 0 : resolved.index, this.tableState.currentPageIndex, undefined, resolved === null || resolved === void 0 ? void 0 : resolved.selector);
                     const loadingOutcome = await (0, rowResolution_1.resolveRowLoading)(smartRow, this.config.strategies.loading, 'skip', (msg) => (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: ${msg}`));
                     if (loadingOutcome !== 'process') {
-                        barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
                         if (loadingOutcome === 'throw') {
                             throw new Error(`[SmartTable] Row ${allRows.length} did not finish loading within ${(_a = this.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.rowLoadingTimeout}ms`);
                         }
                         continue;
                     }
                     if (hasOverrideFilters && !await this.matchesOverrideFilters(currentRows[idx], overrideFilters, map, (_c = options === null || options === void 0 ? void 0 : options.exact) !== null && _c !== void 0 ? _c : false)) {
-                        barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
                         continue;
                     }
                     if (hasSyntheticFilters && !await this.matchesSyntheticFilters(currentRows[idx], syntheticFilters, map, (_d = options === null || options === void 0 ? void 0 : options.exact) !== null && _d !== void 0 ? _d : false)) {
-                        barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
                         continue;
                     }
                     allRows.push(smartRow);
@@ -204,6 +200,7 @@ class RowFinder {
                 useBulk,
                 label: 'findRows',
                 finalScanOnEof: hasPagination,
+                signal: options === null || options === void 0 ? void 0 : options.signal,
             });
             (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: done — ${allRows.length} row(s) collected across ${pagesScanned} page(s)`);
         }
@@ -268,6 +265,7 @@ class RowFinder {
             useBulk,
             label: 'findRow',
             finalScanOnEof: true,
+            signal: options.signal,
         });
         return found;
     }

package/dist/engine/rowResolution.d.ts

@@ -29,7 +29,7 @@ export type RowLoadingOutcome = 'process' | 'skip' | 'throw';
  * 'skip'`), while `map`/`forEach`/`filter` process it as-is (`'process'`) — and map, in that
  * case, never even probes `isRowLoading`. Both are preserved exactly.
  *
- * The helper never throws and never touches the navigation barrier; it returns a decision so
- * each caller keeps its own barrier bookkeeping and error message.
+ * Timeout returns a decision so each caller keeps its own barrier bookkeeping and error
+ * message. Predicate errors propagate unchanged.
  */
 export declare function resolveRowLoading(row: SmartRow, loading: LoadingStrategy | undefined, noTimeoutAction: 'skip' | 'process', log?: (msg: string) => void): Promise<RowLoadingOutcome>;

package/dist/engine/rowResolution.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeRowIndexResult = normalizeRowIndexResult;
 exports.resolveLogicalRowIndex = resolveLogicalRowIndex;
 exports.resolveRowLoading = resolveRowLoading;
+const deadline_1 = require("../utils/deadline");
 /** Extract the numeric index from a {@link RowIndexResult}. */
 function normalizeRowIndexResult(result) {
     return typeof result === 'number' ? { index: result } : result;
@@ -36,8 +37,8 @@ async function resolveLogicalRowIndex(row, config, fallback) {
  * 'skip'`), while `map`/`forEach`/`filter` process it as-is (`'process'`) — and map, in that
  * case, never even probes `isRowLoading`. Both are preserved exactly.
  *
- * The helper never throws and never touches the navigation barrier; it returns a decision so
- * each caller keeps its own barrier bookkeeping and error message.
+ * Timeout returns a decision so each caller keeps its own barrier bookkeeping and error
+ * message. Predicate errors propagate unchanged.
  */
 async function resolveRowLoading(row, loading, noTimeoutAction, log) {
     var _a;
@@ -53,18 +54,21 @@ async function resolveRowLoading(row, loading, noTimeoutAction, log) {
     // map's fast path: with no timeout and a process-default, it never probes isRowLoading.
     if (timeout === undefined && noTimeoutAction === 'process')
         return 'process';
-    if (!(await isRowLoading(row)))
+    const deadline = Date.now() + (timeout !== null && timeout !== void 0 ? timeout : Infinity);
+    const check = () => (0, deadline_1.withinDeadline)(() => isRowLoading(row), deadline, true);
+    if (!(await check()))
         return 'process';
     // Row is loading with no timeout configured → legacy skip (findRows).
     if (timeout === undefined)
         return 'skip';
     log === null || log === void 0 ? void 0 : log(`row ${row.rowIndex} — waiting up to ${timeout}ms for row to load`);
-    const deadline = Date.now() + timeout;
-    let resolved = !(await isRowLoading(row)); // immediate check (handles timeout=0)
+    let resolved = (timeout === 0 || Date.now() < deadline) && !(await check());
     while (!resolved && Date.now() < deadline) {
         // Page accessed lazily (only while actually polling), matching the pre-refactor code.
-        await row.page().waitForTimeout(100);
-        resolved = !(await isRowLoading(row));
+        await row.page().waitForTimeout(Math.min(100, deadline - Date.now()));
+        if (Date.now() >= deadline)
+            break;
+        resolved = !(await check());
     }
     if (resolved)
         return 'process';

package/dist/engine/rowSnapshot.js

@@ -6,6 +6,7 @@ exports.readRowLive = readRowLive;
 const rowResolution_1 = require("./rowResolution");
 const cellNavigation_1 = require("./cellNavigation");
 const debugUtils_1 = require("../utils/debugUtils");
+const deadline_1 = require("../utils/deadline");
 /** `getHeaderCell` for strategy hooks: the table's when available, else an index lookup. */
 function headerCellGetter(env) {
     const { table } = env;
@@ -35,6 +36,15 @@ async function computeSyntheticColumns(env, result, columns) {
     }
 }
 const isBatchRow = (row) => row._inBatch === true || !!row._barrier;
+/** Capture a mounted position's identity once, before readiness or navigation can recycle it. */
+async function resolveSnapshotIdentity(env) {
+    if (!env.renderWindowPosition || !env.config.strategies.resolveRowIndex)
+        return env;
+    const identity = await (0, rowResolution_1.resolveLogicalRowIndex)(env.rowLocator, env.config, () => undefined);
+    // Keep the public SmartRow's mounted position unchanged; all snapshot recovery and
+    // navigation use this read's logical identity. An unknown identity is not position 0.
+    return Object.assign(Object.assign({}, env), { rowIndex: identity === null || identity === void 0 ? void 0 : identity.index, renderWindowPosition: false });
+}
 // ─── Atomic snapshot ─────────────────────────────────────────────────────────
 /** Mounted row whose logical index (per resolveRowIndex) is `rowIndex`; tolerates rows detaching mid-scan. */
 async function rescanForRow(env, rowIndex) {
@@ -107,9 +117,7 @@ async function resolveCloneTarget(env) {
         await config.strategies.contentReady(cloneTarget, env.rootLocator.page());
         // Revalidate: the element may have recycled during the await.
         if (canRepin && await logicalIndexOf(env, cloneTarget) !== rowIndex) {
-            const reFound = await rescanForRow(env, rowIndex);
-            if (reFound)
-                cloneTarget = reFound;
+            cloneTarget = await recoverDriftedRow(env, rowIndex);
         }
     }
     return cloneTarget;
@@ -148,6 +156,7 @@ async function readRowAtomic(env, columns) {
     if (typeof cellSel !== 'string') {
         throw new Error('[SmartTable] toJSON({ atomic: true }) requires cellSelector to be a CSS string, not a function.');
     }
+    env = await resolveSnapshotIdentity(env);
     const page = rootLocator.page();
     const snapshot = await cloneRow(await resolveCloneTarget(env), cellSel);
     // Determine which columns have overrides (need lazy materialization)
@@ -275,7 +284,9 @@ function cellLoadingTimeoutOf(config) {
 async function pollUntil(page, deadline, intervalMs, check, initial) {
     let done = initial;
     while (!done && Date.now() < deadline) {
-        await page.waitForTimeout(intervalMs);
+        await page.waitForTimeout(Math.min(intervalMs, deadline - Date.now()));
+        if (Date.now() >= deadline)
+            break;
         done = await check();
     }
     return done;
@@ -285,11 +296,13 @@ async function pollUntil(page, deadline, intervalMs, check, initial) {
  * indicator mounts. A single false-negative then reads "" and skips
  * onCellLoadingTimeout. Only grace when the cell still looks empty.
  */
-async function graceForLoadingIndicator(page, targetCell, isLoading, timeout) {
-    const peek = await targetCell.evaluate((el) => (el.textContent || '').trim()).catch(() => '');
+async function graceForLoadingIndicator(page, targetCell, isLoading, deadline) {
+    const peek = await (0, deadline_1.withinDeadline)(() => targetCell.evaluate((el) => (el.textContent || '').trim()).catch(() => ''), deadline, null);
+    if (peek === null)
+        return true; // Deadline expired: apply the cell loading timeout policy.
     if (peek !== '')
         return false;
-    return pollUntil(page, Date.now() + Math.min(250, timeout), 25, isLoading, false);
+    return pollUntil(page, Math.min(Date.now() + 250, deadline), 25, isLoading, false);
 }
 /** What to do when a cell is still loading after `cellLoadingTimeout`. */
 async function onStillLoading(env, targetCell, col, timeout) {
@@ -320,18 +333,19 @@ async function waitForCellLoaded(env, targetCell, col) {
     if (!isCellLoading)
         return { read: true };
     const page = env.rootLocator.page();
-    const isLoading = () => isCellLoading(targetCell, col, smart);
     const timeout = cellLoadingTimeoutOf(config);
+    const deadline = Date.now() + (timeout !== null && timeout !== void 0 ? timeout : Infinity);
+    const isLoading = () => (0, deadline_1.withinDeadline)(() => isCellLoading(targetCell, col, smart), deadline, true);
     let loading = await isLoading();
     if (!loading && timeout !== undefined && timeout > 0) {
-        loading = await graceForLoadingIndicator(page, targetCell, isLoading, timeout);
+        loading = await graceForLoadingIndicator(page, targetCell, isLoading, deadline);
     }
     if (!loading || timeout === undefined)
         return { read: true };
     (0, debugUtils_1.logDebug)(config, 'verbose', `toJSON: cell "${col}" — waiting up to ${timeout}ms`);
-    const deadline = Date.now() + timeout;
     const isLoaded = async () => !(await isLoading());
-    const cellResolved = await pollUntil(page, deadline, 100, isLoaded, await isLoaded()); // immediate check (handles timeout=0)
+    const initial = (timeout === 0 || Date.now() < deadline) && await isLoaded();
+    const cellResolved = await pollUntil(page, deadline, 100, isLoaded, initial);
     return cellResolved ? { read: true } : onStillLoading(env, targetCell, col, timeout);
 }
 /**
@@ -340,6 +354,7 @@ async function waitForCellLoaded(env, targetCell, col) {
  */
 async function readRowLive(env, columns) {
     var _a, _b, _c;
+    env = await resolveSnapshotIdentity(env);
     const { config, map, rootLocator, rowIndex } = env;
     const result = {};
     const page = rootLocator.page();

package/dist/engine/scanPages.d.ts

@@ -52,6 +52,11 @@ export interface ScanPagesOptions {
      * Matches runMap / findRows EOF behavior. @default true
      */
     finalScanOnEof?: boolean;
+    /**
+     * Checked before each page and before each advance. When aborted, the scan throws
+     * `signal.reason` instead of returning partial results (#488).
+     */
+    signal?: AbortSignal;
 }
 export declare function scanPages(env: ScanPagesEnv, onPage: (ctx: ScanPageContext) => Promise<ScanDecision>, options: ScanPagesOptions): Promise<{
     pagesScanned: number;

package/dist/engine/scanPages.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanPages = scanPages;
 const debugUtils_1 = require("../utils/debugUtils");
+function throwIfAborted(env, label, signal) {
+    if (!(signal === null || signal === void 0 ? void 0 : signal.aborted))
+        return;
+    (0, debugUtils_1.logDebug)(env.config, 'info', `${label}: aborted via AbortSignal at page ${env.getCurrentPageIndex()}`);
+    throw signal.reason;
+}
 async function scanPages(env, onPage, options) {
     var _a, _b;
     const maxPages = options.maxPages;
@@ -12,14 +18,17 @@ async function scanPages(env, onPage, options) {
     let reachedEnd = false;
     (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: starting (maxPages=${maxPages}, useBulk=${useBulk}, finalScanOnEof=${finalScanOnEof})`);
     while (true) {
+        throwIfAborted(env, label, options.signal);
         if (env.waitForReady) {
             await env.waitForReady();
+            throwIfAborted(env, label, options.signal);
         }
         const decision = await onPage({
             pagesScanned,
             pageIndex: env.getCurrentPageIndex(),
             isFinalScan: reachedEnd,
         });
+        throwIfAborted(env, label, options.signal);
         if (decision === 'stop') {
             (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: onPage returned stop at page ${env.getCurrentPageIndex()}`);
             break;
@@ -27,8 +36,10 @@ async function scanPages(env, onPage, options) {
         if (pagesScanned >= maxPages || reachedEnd) {
             break;
         }
+        throwIfAborted(env, label, options.signal);
         const prevPage = env.getCurrentPageIndex();
         const didAdvance = await env.advancePage(useBulk);
+        throwIfAborted(env, label, options.signal);
         if (!didAdvance) {
             if (finalScanOnEof) {
                 (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: pagination returned false — final scan`);

package/dist/engine/tableIteration.js

@@ -196,6 +196,7 @@ async function runMap(env, callback, options = {}, label = 'map') {
             useBulk,
             label,
             finalScanOnEof: true,
+            signal: options.signal,
         });
         log(env.config, `${label}: complete — ${results.length} result(s) across ${pagesScanned} page(s)`);
     }

package/dist/engine/tableMapper.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TableMapper = void 0;
 const headers_1 = require("../strategies/headers");
 const debugUtils_1 = require("../utils/debugUtils");
+const deadline_1 = require("../utils/deadline");
 class TableMapper {
     constructor(rootLocator, config, resolve) {
         this._headerMap = null;
@@ -21,9 +22,11 @@ class TableMapper {
         this.log('Mapping headers...');
         const headerTimeout = timeout !== null && timeout !== void 0 ? timeout : 3000;
         const startTime = Date.now();
+        const deadline = startTime + headerTimeout;
+        const remaining = () => Math.max(0, deadline - Date.now());
         if (this.config.autoScroll) {
             try {
-                await this.rootLocator.scrollIntoViewIfNeeded({ timeout: 1000 });
+                await (0, deadline_1.withinDeadline)(() => this.rootLocator.scrollIntoViewIfNeeded({ timeout: Math.max(1, Math.min(1000, remaining())) }), deadline, undefined);
             }
             catch (e) { }
         }
@@ -39,22 +42,29 @@ class TableMapper {
         while (Date.now() - startTime < headerTimeout) {
             // 1. Wait for visibility
             try {
-                await headerLoc.first().waitFor({ state: 'visible', timeout: 200 });
+                await (0, deadline_1.withinDeadline)(() => headerLoc.first().waitFor({ state: 'visible', timeout: Math.max(1, Math.min(200, remaining())) }), deadline, undefined);
             }
             catch (e) {
                 // Continue to check existing/loading state even if not strictly "visible" yet
             }
+            if (remaining() <= 0)
+                break;
             // 2. Check Smart Loading State
             if ((_a = this.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isHeaderLoading) {
-                const isStable = !(await this.config.strategies.loading.isHeaderLoading(context));
+                const isStable = !(await (0, deadline_1.withinDeadline)(() => this.config.strategies.loading.isHeaderLoading(context), deadline, true));
                 if (!isStable) {
                     this.log('Headers are loading/unstable... waiting');
-                    await new Promise(r => setTimeout(r, 100));
+                    if (remaining() > 0)
+                        await new Promise(r => setTimeout(r, Math.min(100, remaining())));
                     continue;
                 }
             }
             // 3. Attempt Scan
+            if (remaining() <= 0)
+                break;
             try {
+                // Preserve long-running discovery strategies (e.g. horizontal header scans).
+                // The deadline bounds readiness and retries, not a strategy's own operation.
                 const rawHeaders = await strategy(context);
                 const entries = await this.processHeaders(rawHeaders);
                 // Success — validate before caching so a collision doesn't leave stale state
@@ -72,7 +82,8 @@ class TableMapper {
             catch (e) {
                 lastError = e;
                 this.log(`Header mapping failed. Attempt ${Math.floor((Date.now() - startTime) / 100)}: ${e.message}`);
-                await new Promise(r => setTimeout(r, 100));
+                if (remaining() > 0)
+                    await new Promise(r => setTimeout(r, Math.min(100, remaining())));
             }
         }
         throw lastError || new Error(`Timed out waiting for headers after ${headerTimeout}ms`);

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { PLAYWRIGHT_SMART_TABLE_VERSION } from './packageVersion';
 export { useTable } from './useTable';
-export type { TableConfig, TableResult, SmartRow, SmartCell, Selector, TableSelector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, SyntheticColumnDef, ColumnOverride, ColumnOverrideReadContext, TableStrategies, LoadingStrategy, ViewportStrategy, FilterStrategy, NavigationPrimitives, DedupeStrategy, ContentReadyStrategy, FillStrategy, PaginationStrategy, HeaderStrategy, } from './types';
+export type { TableConfig, TableResult, SmartRow, SmartCell, Selector, TableSelector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, SyntheticColumnDef, ColumnOverride, ColumnOverrideReadContext, TableStrategies, LoadingStrategy, ViewportStrategy, FilterStrategy, NavigationPrimitives, DedupeStrategy, ContentReadyStrategy, RowReadyPredicate, FillStrategy, PaginationStrategy, HeaderStrategy, } from './types';
 export { Strategies } from './strategies';
 export * as presets from './presets';
 /**

package/dist/packageVersion.d.ts

@@ -3,4 +3,4 @@
  * Generated by scripts/embed-version.mjs from package.json
  */
 /** Semver of this package. Use in logs or diagnostics to confirm the installed build. */
-export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.25.0-next.c81cb3d";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.25.0-next.d8860d0";

package/dist/packageVersion.js

@@ -6,4 +6,4 @@ exports.PLAYWRIGHT_SMART_TABLE_VERSION = void 0;
  * Generated by scripts/embed-version.mjs from package.json
  */
 /** Semver of this package. Use in logs or diagnostics to confirm the installed build. */
-exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.25.0-next.c81cb3d";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.25.0-next.d8860d0";

package/dist/strategies/contentReady.d.ts

@@ -1,5 +1,23 @@
-import type { ContentReadyStrategy } from '../types';
+import type { ContentReadyStrategy, RowReadyPredicate } from '../types';
 export declare const ContentReadyStrategies: {
+    /**
+     * Waits in the browser until `predicate(rowElement, arg)` returns a truthy value, e.g. until
+     * a skeleton placeholder is gone or every cell has rendered. Resolves when `timeout` expires
+     * even if the predicate never passed, like the other content-ready strategies.
+     *
+     * Uses `locator.waitForFunction` (Playwright 1.62+), which re-resolves the row on each retry
+     * and polls without a round-trip per check. Older versions poll via `locator.evaluate`.
+     * `timeout` and `interval` must be positive finite milliseconds. `interval` only controls
+     * the older-version fallback; native polling is controlled by Playwright.
+     *
+     * @example
+     * contentReady: Strategies.ContentReady.until(row => !row.querySelector('.skeleton'))
+     */
+    until: <Arg = undefined>(predicate: RowReadyPredicate<Arg>, options?: {
+        arg?: Arg;
+        timeout?: number;
+        interval?: number;
+    }) => ContentReadyStrategy;
     /**
      * Polls the row's text content until two consecutive reads match.
      */

package/dist/strategies/contentReady.js

@@ -1,7 +1,88 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentReadyStrategies = void 0;
+function isTimeout(error) {
+    return (error === null || error === void 0 ? void 0 : error.name) === 'TimeoutError';
+}
+/** Playwright < 1.62 has no `locator.waitForFunction`: poll with one `evaluate` per check. */
+async function pollPredicate(row, page, predicate, arg, timeout, interval) {
+    const deadline = Date.now() + timeout;
+    let source = predicate.toString();
+    // Build a serializable callback; the user predicate executes only inside the browser.
+    const wrap = (expression) => new Function(`return async (row, arg) => Boolean(await (${expression})(row, arg))`)();
+    let evaluateBoolean;
+    try {
+        evaluateBoolean = wrap(source);
+    }
+    catch (_a) {
+        // Like Playwright's serializer, normalize method shorthand into a function expression.
+        source = source.startsWith('async ') ? source.replace(/^async\s+/, 'async function ') : `function ${source}`;
+        evaluateBoolean = wrap(source);
+    }
+    let expired = false;
+    let deadlineTimer;
+    const timeoutReached = new Promise(resolve => {
+        deadlineTimer = setTimeout(() => { expired = true; resolve(); }, timeout);
+    });
+    const poll = async () => {
+        while (!expired && Date.now() < deadline) {
+            // Convert truthiness before serialization, including async DOM-element results.
+            if (await row.evaluate(evaluateBoolean, arg, { timeout: Math.max(1, deadline - Date.now()) }))
+                return;
+            if (expired || Date.now() >= deadline)
+                return;
+            await page.waitForTimeout(Math.min(interval, Math.max(0, deadline - Date.now())));
+        }
+    };
+    try {
+        // evaluate's timeout only bounds locator resolution, not an async predicate's promise.
+        await Promise.race([poll(), timeoutReached]);
+    }
+    finally {
+        clearTimeout(deadlineTimer);
+    }
+}
 exports.ContentReadyStrategies = {
+    /**
+     * Waits in the browser until `predicate(rowElement, arg)` returns a truthy value, e.g. until
+     * a skeleton placeholder is gone or every cell has rendered. Resolves when `timeout` expires
+     * even if the predicate never passed, like the other content-ready strategies.
+     *
+     * Uses `locator.waitForFunction` (Playwright 1.62+), which re-resolves the row on each retry
+     * and polls without a round-trip per check. Older versions poll via `locator.evaluate`.
+     * `timeout` and `interval` must be positive finite milliseconds. `interval` only controls
+     * the older-version fallback; native polling is controlled by Playwright.
+     *
+     * @example
+     * contentReady: Strategies.ContentReady.until(row => !row.querySelector('.skeleton'))
+     */
+    until: (predicate, 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;
+        if (!Number.isFinite(timeout) || timeout <= 0) {
+            throw new Error('ContentReady.until: timeout must be a positive finite number');
+        }
+        if (!Number.isFinite(interval) || interval <= 0) {
+            throw new Error('ContentReady.until: interval must be a positive finite number');
+        }
+        const fn = predicate;
+        const arg = options.arg;
+        return async (row, page) => {
+            try {
+                if (typeof row.waitForFunction === 'function') {
+                    await row.waitForFunction(fn, arg, { timeout });
+                }
+                else {
+                    await pollPredicate(row, page, fn, arg, timeout, interval);
+                }
+            }
+            catch (error) {
+                if (!isTimeout(error))
+                    throw error;
+            }
+        };
+    },
     /**
      * Polls the row's text content until two consecutive reads match.
      */

package/dist/strategies/dedupe.d.ts

@@ -1,8 +1,11 @@
 import { DedupeStrategy } from '../types';
 export declare const DedupeStrategies: {
     /**
-     * Deduplicates rows based on their vertical position (Y coordinate).
-     * Useful for virtualized tables where row DOM elements are reused but content changes.
+     * Groups rows by their viewport Y coordinate, rounded to a pixel bucket.
+     * Only applicable when each screen position represents the same record for the entire scan.
+     * Scrolling or pagination can place different records at the same position and silently drop them.
+     * @deprecated Prefer a stable record key, e.g. `async row => row.getCell('ID').innerText()`.
+     * Do not use for recycled virtualized rows or paginated tables.
      * @param tolerance Pixel tolerance for position comparison (default: 2)
      */
     byTopPosition: (tolerance?: number) => DedupeStrategy;

package/dist/strategies/dedupe.js

@@ -3,8 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DedupeStrategies = void 0;
 exports.DedupeStrategies = {
     /**
-     * Deduplicates rows based on their vertical position (Y coordinate).
-     * Useful for virtualized tables where row DOM elements are reused but content changes.
+     * Groups rows by their viewport Y coordinate, rounded to a pixel bucket.
+     * Only applicable when each screen position represents the same record for the entire scan.
+     * Scrolling or pagination can place different records at the same position and silently drop them.
+     * @deprecated Prefer a stable record key, e.g. `async row => row.getCell('ID').innerText()`.
+     * Do not use for recycled virtualized rows or paginated tables.
      * @param tolerance Pixel tolerance for position comparison (default: 2)
      */
     byTopPosition: (tolerance = 2) => async (row) => {

package/dist/strategies/index.d.ts

@@ -98,6 +98,11 @@ export declare const Strategies: {
         dataAttribute: (options?: import("./viewport").DataAttributeViewportOptions) => import("..").ViewportStrategy;
     };
     ContentReady: {
+        until: <Arg = undefined>(predicate: import("..").RowReadyPredicate<Arg>, options?: {
+            arg?: Arg;
+            timeout?: number;
+            interval?: number;
+        }) => import("..").ContentReadyStrategy;
         textStable: (options?: {
             timeout?: number;
             interval?: number;

package/dist/types.d.ts

@@ -210,9 +210,9 @@ export interface ViewportStrategy {
     scrollToColumn?: (context: TableContext, colIndex: number) => Promise<void>;
     /**
      * When true, disables the automatic memoization of getVisibleColumnRange and
-     * getVisibleRowRange results. By default the library caches each range value and
-     * invalidates it after the corresponding scroll call, eliminating redundant DOM
-     * evaluate() round-trips between scrolls.
+     * getVisibleRowRange results within a single cell-navigation operation. Geometry
+     * is refreshed for each new read and around scroll calls. Row membership is not
+     * memoized by the library. Caches never persist across scans, resets, or revalidation.
      */
     disableCache?: boolean;
 }
@@ -426,8 +426,15 @@ export interface PaginationPrimitives {
     detectCurrentPage?: (root: import('@playwright/test').Locator) => number | Promise<number>;
 }
 export type PaginationStrategy = PaginationPrimitives;
+/**
+ * Returns a stable record key across the entire scan, including page advances.
+ * Different records must have different keys; viewport coordinates and mounted DOM indices
+ * are not stable identities in recycled or paginated tables.
+ */
 export type DedupeStrategy = (row: SmartRow) => string | number | Promise<string | number>;
 export type ContentReadyStrategy = (row: Locator, page: Page) => Promise<void>;
+/** Predicate for `Strategies.ContentReady.until`. Runs in the browser with the row element, so it must not close over test-side variables; pass values via `arg`. */
+export type RowReadyPredicate<Arg = undefined> = (row: HTMLElement | SVGElement, arg: Arg) => unknown;
 export type FillStrategy = (options: {
     row: SmartRow;
     columnName: string;
@@ -524,6 +531,7 @@ export interface LoadingStrategy {
      * How long (ms) to wait for a loading row to resolve before applying onRowLoadingTimeout.
      * Honored by findRows AND by map/forEach/filter, where the wait runs before the dedupe
      * strategy so content-based dedupe keys see the row's final loaded state.
+     * Includes time spent awaiting the loading predicate, even if it never settles.
      * When not set (backward-compatible behavior): findRows skips loading rows immediately;
      * map/forEach/filter process them as-is.
      */
@@ -544,6 +552,7 @@ export interface LoadingStrategy {
     isCellLoading?: (cell: import('@playwright/test').Locator, columnName: string, row: SmartRow) => Promise<boolean>;
     /**
      * How long (ms) to wait for a loading cell to resolve before applying onCellLoadingTimeout.
+     * Includes predicate evaluation and any initial rendering grace period.
      * When not set and isCellLoading returns true, the cell is read as-is immediately.
      */
     cellLoadingTimeout?: number;
@@ -638,12 +647,18 @@ export interface TableStrategies {
      * Without this, the clone captures stale content from the previous occupant of the
      * DOM slot — the element is at the correct position but React hasn't re-rendered yet.
      *
-     * Use `Strategies.ContentReady.textStable()` for the built-in text-polling strategy.
+     * Built-ins: `Strategies.ContentReady.textStable()` (text stops changing),
+     * `mutationSettled()` (no DOM mutations for a quiet period), and `until(predicate)`
+     * (an in-browser condition holds, e.g. no skeleton placeholder).
      *
      * @example
      * strategies: {
      *   contentReady: Strategies.ContentReady.textStable({ timeout: 500 }),
      * }
+     * @example
+     * strategies: {
+     *   contentReady: Strategies.ContentReady.until(row => !row.querySelector('.skeleton')),
+     * }
      */
     contentReady?: ContentReadyStrategy;
     /**
@@ -794,6 +809,11 @@ export type RowIterationOptions = {
      * @default false — uses goNext for one-page-at-a-time advancement
      */
     useBulkPagination?: boolean;
+    /**
+     * Cancels the iteration between pages. When aborted, the call rejects with
+     * `signal.reason` (rows already processed are not returned).
+     */
+    signal?: AbortSignal;
 };
 /**
  * Result of {@link useTable}. Implements `AsyncIterable` — `for await (const { row } of table)`
@@ -876,31 +896,37 @@ export interface TableResult<T = any> extends AsyncIterable<{
      * is not configured. Also throws if the row cannot be reached (no silent wrong-row fallback).
      *
      * @param index 0-based logical/data-model row index
-     * @param options - `maxPages` bounds how far to scroll/paginate (defaults to config.maxPages)
+     * @param options - `maxPages` bounds how far to scroll/paginate (defaults to config.maxPages).
+     * `signal` cancels the page scan; the call rejects with `signal.reason`.
      */
     findRowByIndex: (index: number, options?: {
         maxPages?: number;
+        signal?: AbortSignal;
     }) => Promise<SmartRow<T>>;
     /**
      * ASYNC: Searches for a single row across pages using pagination.
      * Auto-initializes the table if not already initialized.
      * @param filters - The filter criteria to match
-     * @param options - Search options including exact match and max pages
+     * @param options - Search options including exact match and max pages. `signal` cancels the page scan; the call rejects with `signal.reason`.
      */
     findRow: (filters: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
+        signal?: AbortSignal;
     }) => Promise<SmartRow<T>>;
     /**
      * ASYNC: Searches for all matching rows across pages using pagination.
      * Auto-initializes the table if not already initialized.
+     * Returned rows can be read independently, including with `concurrency: 'synchronized'`.
+     * Use synchronized `map()` for coordinated column scrolling across virtualized rows.
      * @param filters - The filter criteria to match (omit or pass {} for all rows)
-     * @param options - Search options (exact, maxPages). `useBulkPagination` defaults to `false`: pages advance one at a time via `goNext` so no intermediate page is skipped. Set it to `true` to opt into `goNextBulk` (faster, but skips the rows on jumped-over pages).
+     * @param options - Search options (exact, maxPages). `useBulkPagination` defaults to `false`: pages advance one at a time via `goNext` so no intermediate page is skipped. Set it to `true` to opt into `goNextBulk` (faster, but skips the rows on jumped-over pages). `signal` cancels the page scan; the call rejects with `signal.reason`.
      */
     findRows: (filters?: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
         useBulkPagination?: boolean;
+        signal?: AbortSignal;
     }) => Promise<SmartRowArray<T>>;
     /**
      * Resolves the named column and scrolls it into view.
@@ -911,11 +937,13 @@ export interface TableResult<T = any> extends AsyncIterable<{
     /**
      * Counts the number of rows, optionally filtered.
      * Without arguments, counts all rows. With filters, counts only matching rows.
-     * Paginates when pagination is configured.
+     * Paginates when pagination is configured. `signal` cancels the page scan; the call
+     * rejects with `signal.reason` (the table is still reset to page 1).
      */
     countRows: (filters?: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
+        signal?: AbortSignal;
     }) => Promise<number>;
     /**
      * Iterates over rows and extracts the value of a single column.

package/dist/useTable.js

@@ -53,52 +53,6 @@ const useTable = (rootLocator, configOptions = {}) => {
         }
     };
     const config = Object.assign(Object.assign({ rowSelector: "tbody tr", headerSelector: "thead th", cellSelector: "td", maxPages: 1, headerTransformer: ({ text }) => text, autoScroll: true, onReset: async () => { } }, configOptions), { strategies: Object.assign(Object.assign({}, defaultStrategies), configOptions.strategies) });
-    // Automatically memoize viewport range oracles so user-provided functions are
-    // pure DOM queries with no cache bookkeeping. Invalidated after each scroll call.
-    let _clearViewportCache = null;
-    if (config.strategies.viewport && !config.strategies.viewport.disableCache) {
-        const vp = config.strategies.viewport;
-        let colRangeCache = null;
-        let rowRangeCache = null;
-        let rowIndicesCache = null;
-        _clearViewportCache = () => {
-            colRangeCache = null;
-            rowRangeCache = null;
-            rowIndicesCache = null;
-        };
-        config.strategies.viewport = Object.assign(Object.assign({}, vp), { getVisibleColumnRange: vp.getVisibleColumnRange
-                ? async (ctx) => {
-                    if (!colRangeCache)
-                        colRangeCache = await vp.getVisibleColumnRange(ctx);
-                    return colRangeCache;
-                }
-                : undefined, getVisibleRowRange: vp.getVisibleRowRange
-                ? async (ctx) => {
-                    if (!rowRangeCache)
-                        rowRangeCache = await vp.getVisibleRowRange(ctx);
-                    return rowRangeCache;
-                }
-                : undefined, getVisibleRowIndices: vp.getVisibleRowIndices
-                ? async (ctx) => {
-                    if (!rowIndicesCache)
-                        rowIndicesCache = await vp.getVisibleRowIndices(ctx);
-                    return rowIndicesCache;
-                }
-                : undefined, scrollToColumn: vp.scrollToColumn
-                ? async (ctx, colIndex) => {
-                    colRangeCache = null;
-                    rowRangeCache = null;
-                    rowIndicesCache = null;
-                    await vp.scrollToColumn(ctx, colIndex);
-                }
-                : undefined, scrollToRow: vp.scrollToRow
-                ? async (ctx, rowIndex) => {
-                    rowRangeCache = null;
-                    rowIndicesCache = null;
-                    await vp.scrollToRow(ctx, rowIndex);
-                }
-                : undefined });
-    }
     const resolve = (item, parent) => {
         if (typeof item === 'string')
             return parent.locator(item);
@@ -213,10 +167,6 @@ const useTable = (rootLocator, configOptions = {}) => {
         if (pagesJumped > 0) {
             tableState.currentPageIndex += pagesJumped;
             log(`_advancePage: ${primitive} advanced ${pagesJumped} page(s) — now at page ${tableState.currentPageIndex}`);
-            // Invalidate viewport caches: after a page advance the row set changes and the
-            // column renderer may recalculate (e.g. scrollbar appearance changes available width).
-            if (_clearViewportCache)
-                _clearViewportCache();
             await (0, debugUtils_1.debugDelay)(config, 'pagination');
         }
         else {

package/dist/utils/deadline.d.ts

@@ -0,0 +1,2 @@
+/** Bound one asynchronous check by an existing deadline, without cancelling its underlying work. */
+export declare function withinDeadline<T>(check: () => Promise<T>, deadline: number, expiredValue: T): Promise<T>;

package/dist/utils/deadline.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withinDeadline = withinDeadline;
+/** Bound one asynchronous check by an existing deadline, without cancelling its underlying work. */
+async function withinDeadline(check, deadline, expiredValue) {
+    if (!Number.isFinite(deadline))
+        return check();
+    let timer;
+    try {
+        const expired = new Promise(resolve => {
+            timer = setTimeout(() => resolve(expiredValue), Math.max(0, deadline - Date.now()));
+        });
+        // A late rejection is handled by the race even after the deadline wins.
+        return await Promise.race([check(), expired]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/utils/memoizeViewport.d.ts

@@ -0,0 +1,6 @@
+import type { ViewportStrategy } from '../types';
+/** Cache geometry only for one navigation; scans and later reads use the original oracles. */
+export declare function memoizeViewport(viewport: ViewportStrategy): {
+    viewport: ViewportStrategy;
+    clear: () => void;
+};

package/dist/utils/memoizeViewport.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoizeViewport = memoizeViewport;
+/** Cache geometry only for one navigation; scans and later reads use the original oracles. */
+function memoizeViewport(viewport) {
+    if (viewport.disableCache)
+        return { viewport, clear: () => { } };
+    let columns;
+    let rows;
+    const clear = () => { columns = undefined; rows = undefined; };
+    const wrapScroll = (scroll) => scroll && (async (context, index) => {
+        clear();
+        try {
+            await scroll.call(viewport, context, index);
+        }
+        finally {
+            clear();
+        }
+    });
+    return {
+        clear,
+        viewport: Object.assign(Object.assign({}, viewport), { getVisibleColumnRange: viewport.getVisibleColumnRange
+                ? context => columns !== null && columns !== void 0 ? columns : (columns = viewport.getVisibleColumnRange(context))
+                : undefined, getVisibleRowRange: viewport.getVisibleRowRange
+                ? context => rows !== null && rows !== void 0 ? rows : (rows = viewport.getVisibleRowRange(context))
+                : undefined, scrollToColumn: wrapScroll(viewport.scrollToColumn), scrollToRow: wrapScroll(viewport.scrollToRow) }),
+    };
+}

package/dist/utils/smartRowArray.d.ts

@@ -4,7 +4,7 @@ import { SmartRow } from '../types';
  */
 export interface SmartRowArray<T = any> extends Array<SmartRow<T>> {
     /**
-     * Converts all rows to JSON objects
+     * Converts all rows to JSON objects, reading sequentially to avoid competing viewport moves.
      */
     toJSON(): Promise<T[]>;
 }

package/dist/utils/smartRowArray.js

@@ -7,7 +7,10 @@ exports.createSmartRowArray = createSmartRowArray;
 function createSmartRowArray(rows) {
     const arr = rows;
     arr.toJSON = async () => {
-        return Promise.all(rows.map(r => r.toJSON()));
+        const results = [];
+        for (const row of rows)
+            results.push(await row.toJSON());
+        return results;
     };
     return arr;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.25.0-next.c81cb3d",
+  "version": "6.25.0-next.d8860d0",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",