@rickcedwhat/playwright-smart-table 6.14.0 → 6.16.0

package/README.md

@@ -1,52 +1,38 @@
 # Playwright Smart Table
 
-**Production-ready table testing for Playwright with smart column-aware locators.**
+**Dealing with tables sucks. Locators are brittle, hard to read, and break the moment a column moves or pagination kicks in.**
+
+Playwright Smart Table lets you find rows by column name instead of fragile DOM positions. You describe your table — it does the rest.
 
 [![npm version](https://img.shields.io/github/package-json/v/rickcedwhat/playwright-smart-table?label=npm&color=blue&t=2)](https://www.npmjs.com/package/@rickcedwhat/playwright-smart-table)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![CodeRabbit Reviews](https://img.shields.io/coderabbit/prs/github/rickcedwhat/playwright-smart-table?utm_source=oss&utm_medium=github&utm_campaign=rickcedwhat%2Fplaywright-smart-table&labelColor=171717&color=FF570A&link=https%3A%2F%2Fcoderabbit.ai&label=CodeRabbit+Reviews)](https://coderabbit.ai)
 
 ## 📚 [Full Documentation →](https://rickcedwhat.github.io/playwright-smart-table/)
 
 ---
 
-## The Problem
-
-Testing HTML tables in Playwright is fragile by default:
-
 ```typescript
-// ❌ Breaks if columns reorder
-const email = await page.locator('tbody tr').nth(2).locator('td').nth(3).textContent();
-
-// ❌ Manual column mapping every time
-const headers = await page.locator('thead th').allTextContents();
-const emailIndex = headers.indexOf('Email');
-const email = await row.locator('td').nth(emailIndex).textContent();
+// ❌ Before — breaks if columns reorder
+const row = page.locator('tbody tr')
+  .filter({ has: page.locator('td:nth-child(1)', { hasText: 'John' }) })
+  .filter({ has: page.locator('td:nth-child(2)', { hasText: 'Doe' }) })
+const email = await row.locator('td:nth-child(3)').innerText()
 ```
 
-## The Solution
-
 ```typescript
-// ✅ Column-aware — survives column reordering
-const row = table.getRow({ Name: 'John Doe' });
-const email = await row.getCell('Email').textContent();
-
-// ✅ Search across pages
-const allEngineers = await table.findRows({ Department: 'Engineering' }, { maxPages: 5 });
-
-// ✅ Iterate with forEach, map, filter, or for await...of
-await table.forEach(async ({ row }) => {
-  await row.getCell('Checkbox').click();
-});
+// ✅ After — column-aware, survives reordering
+const row = table.getRow({ firstName: 'John', lastName: 'Doe' })
+const email = await row.getCell('Email').innerText()
 ```
 
+---
+
 ## Installation
 
 ```bash
 npm install @rickcedwhat/playwright-smart-table
 ```
 
-
 ## Quick Start
 
 ```typescript
@@ -58,14 +44,13 @@ const row = table.getRow({ Name: 'John Doe' });
 const email = await row.getCell('Email').innerText();
 ```
 
-## Key Features
+## Features
 
-- 🎯 **Column-aware locators** — find rows and cells by name, not index
-- 📄 **Pagination-aware search** — `findRows` and `forEach` scan across pages automatically
-- 🔁 **Iteration methods** — `forEach`, `map`, `filter`, and `for await...of`
-- 🛠️ **Debug mode** — slow motion playback and structured logs
-- 🔌 **Extensible strategies** — plug in any table implementation or pagination shape
-- 💪 **Full TypeScript support**
+- [Row access](https://rickcedwhat.github.io/playwright-smart-table/guide/query/) — find rows by column name, not DOM index
+- [Pagination search](https://rickcedwhat.github.io/playwright-smart-table/guide/query/find-rows) — `findRow` and `findRows` scan across pages automatically
+- [Iteration](https://rickcedwhat.github.io/playwright-smart-table/guide/query/iterate) — `forEach`, `map`, `filter`, with early exit via `stop()`
+- [Table config](https://rickcedwhat.github.io/playwright-smart-table/guide/describe/) — plug in any pagination shape, virtual scroll, or custom header logic
+- [Fill / edit cells](https://rickcedwhat.github.io/playwright-smart-table/guide/query/write) — write values back into table cells
 
 ---
 
@@ -73,5 +58,6 @@ const email = await row.getCell('Email').innerText();
 - [npm Package](https://www.npmjs.com/package/@rickcedwhat/playwright-smart-table)
 - [GitHub Repository](https://github.com/rickcedwhat/playwright-smart-table)
 - [Issues](https://github.com/rickcedwhat/playwright-smart-table/issues)
+- [Discussions](https://github.com/rickcedwhat/playwright-smart-table/discussions) — questions and ideas
 
 MIT © Cedrick Catalan

package/dist/engine/rowFinder.d.ts

@@ -3,6 +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';
 export declare class RowFinder<T = any> {
     private rootLocator;
     private config;
@@ -10,10 +11,11 @@ export declare class RowFinder<T = any> {
     private tableMapper;
     private makeSmartRow;
     private tableState;
+    private advancePage;
     private resolve;
-    constructor(rootLocator: Locator, config: FinalTableConfig, resolve: (item: Selector, parent: Locator | Page) => Locator, filterEngine: FilterEngine, tableMapper: TableMapper, makeSmartRow: (loc: Locator, map: Map<string, number>, index: number | undefined, tablePageIndex?: number) => SmartRow<T>, tableState?: {
+    constructor(rootLocator: Locator, config: FinalTableConfig, resolve: (item: Selector, parent: Locator | Page) => Locator, filterEngine: FilterEngine, tableMapper: TableMapper, makeSmartRow: (loc: Locator, map: Map<string, number>, index: number | undefined, tablePageIndex?: number, barrier?: NavigationBarrier) => SmartRow<T>, tableState?: {
         currentPageIndex: number;
-    });
+    }, advancePage?: (useBulk: boolean) => Promise<boolean>);
     findRow(filters: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;

package/dist/engine/rowFinder.js

@@ -3,17 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RowFinder = void 0;
 const debugUtils_1 = require("../utils/debugUtils");
 const smartRowArray_1 = require("../utils/smartRowArray");
-const validation_1 = require("../strategies/validation");
 const elementTracker_1 = require("../utils/elementTracker");
 const sentinel_1 = require("../utils/sentinel");
+const navigationBarrier_1 = require("../utils/navigationBarrier");
 class RowFinder {
-    constructor(rootLocator, config, resolve, filterEngine, tableMapper, makeSmartRow, tableState = { currentPageIndex: 0 }) {
+    constructor(rootLocator, config, resolve, filterEngine, tableMapper, makeSmartRow, tableState = { currentPageIndex: 0 }, advancePage = async () => false) {
         this.rootLocator = rootLocator;
         this.config = config;
         this.filterEngine = filterEngine;
         this.tableMapper = tableMapper;
         this.makeSmartRow = makeSmartRow;
         this.tableState = tableState;
+        this.advancePage = advancePage;
         this.resolve = resolve;
     }
     async findRow(filters, options = {}) {
@@ -31,12 +32,12 @@ class RowFinder {
         await (0, debugUtils_1.debugDelay)(this.config, 'findRow');
         const sentinel = this.resolve(this.config.rowSelector, this.rootLocator)
             .filter({ hasText: "___SENTINEL_ROW_NOT_FOUND___" + Date.now() });
-        const smartRow = this.makeSmartRow(sentinel, await this.tableMapper.getMap(), 0);
+        const smartRow = this.makeSmartRow(sentinel, await this.tableMapper.getMap(), undefined);
         smartRow[sentinel_1.SENTINEL_ROW] = true;
         return smartRow;
     }
     async findRows(filters = {}, options) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         const filtersRecord = filters;
         const map = await this.tableMapper.getMap();
         const allRows = [];
@@ -64,12 +65,16 @@ class RowFinder {
                     : undefined;
                 const onRowLoadingTimeout = (_e = (_d = this.config.strategies.loading) === null || _d === void 0 ? void 0 : _d.onRowLoadingTimeout) !== null && _e !== void 0 ? _e : 'read-as-is';
                 let added = 0;
+                // One barrier per batch — synchronizes cell navigation across all rows in this page's results
+                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 smartRow = this.makeSmartRow(currentRows[idx], map, allRows.length, this.tableState.currentPageIndex);
+                    const smartRow = this.makeSmartRow(currentRows[idx], map, allRows.length, this.tableState.currentPageIndex, barrier);
                     if (isRowLoading && await isRowLoading(smartRow)) {
                         if (rowLoadingTimeout === undefined) {
                             // No timeout configured (or invalid value) — legacy skip behavior
                             (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: page ${this.tableState.currentPageIndex} — row skipped (isRowLoading=true, no timeout)`);
+                            barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
                             continue;
                         }
                         // Wait up to rowLoadingTimeout ms (0 = one immediate re-check, no polling)
@@ -82,9 +87,12 @@ class RowFinder {
                         }
                         if (!resolved) {
                             (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: row ${allRows.length} — still loading after ${rowLoadingTimeout}ms, action: ${onRowLoadingTimeout}`);
-                            if (onRowLoadingTimeout === 'skip')
+                            if (onRowLoadingTimeout === 'skip') {
+                                barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
                                 continue;
+                            }
                             if (onRowLoadingTimeout === 'throw') {
+                                barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
                                 throw new Error(`[SmartTable] Row ${allRows.length} did not finish loading within ${rowLoadingTimeout}ms`);
                             }
                             // 'read-as-is': fall through and add the row
@@ -102,31 +110,14 @@ class RowFinder {
             await collectMatches();
             // Pagination Loop
             while (pagesScanned < effectiveMaxPages && this.config.strategies.pagination) {
-                const context = {
-                    root: this.rootLocator,
-                    config: this.config,
-                    resolve: this.resolve,
-                    page: this.rootLocator.page()
-                };
-                let paginationResult;
                 const useBulk = (options === null || options === void 0 ? void 0 : options.useBulkPagination) !== false && !!((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk);
-                if (useBulk) {
-                    paginationResult = await this.config.strategies.pagination.goNextBulk(context);
-                }
-                else if ((_d = this.config.strategies.pagination) === null || _d === void 0 ? void 0 : _d.goNext) {
-                    paginationResult = await this.config.strategies.pagination.goNext(context);
-                }
-                else {
-                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: no pagination primitive — stopping`);
-                    break;
-                }
-                const didPaginate = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
+                const prevPage = this.tableState.currentPageIndex;
+                const didPaginate = await this.advancePage(useBulk);
                 if (!didPaginate) {
                     (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: pagination returned false — end of data`);
                     break;
                 }
-                const pagesJumped = typeof paginationResult === 'number' ? paginationResult : 1;
-                this.tableState.currentPageIndex += pagesJumped;
+                const pagesJumped = this.tableState.currentPageIndex - prevPage;
                 pagesScanned += pagesJumped;
                 (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: advanced ${pagesJumped} page(s), now at page ${this.tableState.currentPageIndex}`);
                 await (0, debugUtils_1.debugDelay)(this.config, 'pagination');
@@ -140,7 +131,7 @@ class RowFinder {
         return (0, smartRowArray_1.createSmartRowArray)(allRows);
     }
     async findRowLocator(filters, options = {}) {
-        var _a, _b;
+        var _a, _b, _c;
         const map = await this.tableMapper.getMap();
         const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages;
         let pagesScanned = 1;
@@ -183,29 +174,11 @@ class RowFinder {
                 return matchedRows.first();
             if (pagesScanned < effectiveMaxPages) {
                 (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: Not found. Attempting pagination...`);
-                const context = {
-                    root: this.rootLocator,
-                    config: this.config,
-                    resolve: this.resolve,
-                    page: this.rootLocator.page()
-                };
-                let paginationResult;
-                const pagination = this.config.strategies.pagination;
-                const useBulk = options.useBulkPagination !== false && !!(pagination === null || pagination === void 0 ? void 0 : pagination.goNextBulk);
-                if (useBulk && (pagination === null || pagination === void 0 ? void 0 : pagination.goNextBulk)) {
-                    paginationResult = await pagination.goNextBulk(context);
-                }
-                else if (pagination === null || pagination === void 0 ? void 0 : pagination.goNext) {
-                    paginationResult = await pagination.goNext(context);
-                }
-                else {
-                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: Pagination failed (no goNext or goNextBulk primitive).`);
-                    return null;
-                }
-                const didLoadMore = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
+                const useBulk = options.useBulkPagination !== false && !!((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk);
+                const prevPage = this.tableState.currentPageIndex;
+                const didLoadMore = await this.advancePage(useBulk);
                 if (didLoadMore) {
-                    const pagesJumped = typeof paginationResult === 'number' ? paginationResult : 1;
-                    this.tableState.currentPageIndex += pagesJumped;
+                    const pagesJumped = this.tableState.currentPageIndex - prevPage;
                     pagesScanned += pagesJumped;
                     (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRowLocator: advanced ${pagesJumped} page(s), now at page ${this.tableState.currentPageIndex}`);
                     await (0, debugUtils_1.debugDelay)(this.config, 'pagination');

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.14.0";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.16.0";

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.14.0";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.16.0";

package/dist/presets/glide/index.d.ts

@@ -36,3 +36,4 @@ export declare function createGlide(options?: GlideOptions): Partial<TableConfig
 export declare const Glide: Partial<TableConfig> & {
     Strategies: typeof GlideStrategies;
 };
+export { Glide as glide };

package/dist/presets/glide/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Glide = exports.GlideStrategies = exports.createGlideViewport = void 0;
+exports.glide = exports.Glide = exports.GlideStrategies = exports.createGlideViewport = void 0;
 exports.createGlide = createGlide;
 const headers_1 = require("./headers");
 const pagination_1 = require("../../strategies/pagination");
@@ -75,9 +75,15 @@ const glideGetActiveCell = async ({ page }) => {
     let rowIndex = -1;
     let columnIndex = -1;
     if (parts.length >= 4 && parts[0] === 'glide' && parts[1] === 'cell') {
-        columnIndex = parseInt(parts[2]) - 1;
+        columnIndex = parseInt(parts[2]); // 0-based in Glide's id format: glide-cell-{col}-{row}
         rowIndex = parseInt(parts[3]);
     }
+    else if (id !== '') {
+        throw new Error(`Glide preset: focused element has id "${id}" which does not match the expected format "glide-cell-{colIndex}-{rowIndex}". ` +
+            `Glide may have changed its internal id format. Please open an issue at https://github.com/rickcedwhat/playwright-smart-table/issues.`);
+    }
+    if (rowIndex === -1 || columnIndex === -1)
+        return null;
     return {
         rowIndex,
         columnIndex,
@@ -129,3 +135,4 @@ const GlidePreset = {
     strategies: GlideDefaultStrategies
 };
 exports.Glide = Object.defineProperty(GlidePreset, 'Strategies', { get: () => exports.GlideStrategies, enumerable: false });
+exports.glide = exports.Glide;

package/dist/presets/index.d.ts

@@ -1,4 +1,4 @@
 export { muiTable, muiDataGrid } from './mui';
-export { RDG as rdg } from './rdg';
+export { RDG as rdg, RDG2D as rdg2D } from './rdg';
 export { Glide as glide, createGlide, createGlideViewport } from './glide';
 export type { GlideOptions, GlideViewportOptions } from './glide';

package/dist/presets/index.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGlideViewport = exports.createGlide = exports.glide = exports.rdg = exports.muiDataGrid = exports.muiTable = void 0;
+exports.createGlideViewport = exports.createGlide = exports.glide = exports.rdg2D = exports.rdg = exports.muiDataGrid = exports.muiTable = void 0;
 var mui_1 = require("./mui");
 Object.defineProperty(exports, "muiTable", { enumerable: true, get: function () { return mui_1.muiTable; } });
 Object.defineProperty(exports, "muiDataGrid", { enumerable: true, get: function () { return mui_1.muiDataGrid; } });
 var rdg_1 = require("./rdg");
 Object.defineProperty(exports, "rdg", { enumerable: true, get: function () { return rdg_1.RDG; } });
+Object.defineProperty(exports, "rdg2D", { enumerable: true, get: function () { return rdg_1.RDG2D; } });
 var glide_1 = require("./glide");
 Object.defineProperty(exports, "glide", { enumerable: true, get: function () { return glide_1.Glide; } });
 Object.defineProperty(exports, "createGlide", { enumerable: true, get: function () { return glide_1.createGlide; } });

package/dist/presets/mui.js

@@ -237,8 +237,6 @@ exports.muiDataGrid = {
                     else {
                         await header.click({ force: true });
                     }
-                    // Sorting can trigger large re-renders/virtualization shifts
-                    await context.page.waitForTimeout(500);
                     // Wait for stabilization (using DataGrid specific overlay check inside helper)
                     const displayedRows = context.root.locator('.MuiTablePagination-displayedRows');
                     const text = await displayedRows.innerText().catch(() => '');

package/dist/presets/rdg.d.ts

@@ -1,4 +1,4 @@
-import { TableContext, TableConfig } from '../types';
+import { TableContext, TableConfig, ViewportStrategy } from '../types';
 /** Full strategies for React Data Grid. Use when you want to supply your own selectors: strategies: Plugins.RDG.Strategies */
 export declare const RDGStrategies: {
     header: (context: TableContext) => Promise<string[]>;
@@ -15,3 +15,20 @@ export declare const RDGStrategies: {
 export declare const RDG: Partial<TableConfig> & {
     Strategies: typeof RDGStrategies;
 };
+export declare const RDG2DStrategies: {
+    viewport: ViewportStrategy;
+    header: (context: TableContext) => Promise<string[]>;
+    getCellLocator: ({ row, columnIndex }: any) => any;
+    navigation: {
+        goRight: ({ root, page }: any) => Promise<void>;
+        goLeft: ({ root, page }: any) => Promise<void>;
+        goDown: ({ root, page }: any) => Promise<void>;
+        goUp: ({ root, page }: any) => Promise<void>;
+        goHome: ({ root, page }: any) => Promise<void>;
+    };
+    pagination: import("..").PaginationPrimitives;
+};
+export declare const RDG2D: Partial<TableConfig> & {
+    Strategies: typeof RDG2DStrategies;
+};
+export { RDG as rdg, RDG2D as rdg2D };

package/dist/presets/rdg.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RDG = exports.RDGStrategies = void 0;
+exports.rdg2D = exports.rdg = exports.RDG2D = exports.RDG2DStrategies = exports.RDG = exports.RDGStrategies = void 0;
 const pagination_1 = require("../strategies/pagination");
 const stabilization_1 = require("../strategies/stabilization");
 /**
@@ -114,3 +114,74 @@ const RDGPreset = {
     strategies: RDGDefaultStrategies
 };
 exports.RDG = Object.defineProperty(RDGPreset, 'Strategies', { get: () => exports.RDGStrategies, enumerable: false });
+exports.rdg = exports.RDG;
+// ---------------------------------------------------------------------------
+// rdg2D — React Data Grid with both rows AND columns virtualized
+// ---------------------------------------------------------------------------
+const rdg2DViewportStrategy = {
+    getVisibleRowRange: async ({ root }) => {
+        return root.evaluate((el) => {
+            const rows = [...el.querySelectorAll('[role="row"][aria-rowindex]')];
+            const indices = rows.map(r => parseInt(r.getAttribute('aria-rowindex') || '0', 10) - 1);
+            if (!indices.length)
+                return { first: 0, last: 0 };
+            return { first: Math.min(...indices), last: Math.max(...indices) };
+        });
+    },
+    getVisibleColumnRange: async ({ root }) => {
+        return root.evaluate((el) => {
+            const cells = [...el.querySelectorAll('[role="gridcell"][aria-colindex]')];
+            const indices = cells.map(c => parseInt(c.getAttribute('aria-colindex') || '0', 10) - 1);
+            if (!indices.length)
+                return { first: 0, last: 0 };
+            return { first: Math.min(...indices), last: Math.max(...indices) };
+        });
+    },
+    scrollToRow: async ({ root }, rowIndex) => {
+        await root.evaluate((el, rowIndex) => {
+            const grid = (el.querySelector('[role="grid"]') || el.closest('[role="grid"]') || el);
+            // Try to locate the target row by aria-rowindex (1-based in RDG)
+            const ariaIndex = rowIndex + 1;
+            const targetRow = el.querySelector(`[role="row"][aria-rowindex="${ariaIndex}"]`);
+            if (targetRow) {
+                const top = parseInt(targetRow.style.top || '0', 10);
+                grid.scrollTop = Math.max(0, top - grid.clientHeight / 3);
+                return;
+            }
+            // Row not in DOM — estimate position from an actual visible row's height
+            const anyRow = el.querySelector('[role="row"][aria-rowindex]');
+            const rowHeight = anyRow ? anyRow.getBoundingClientRect().height || 35 : 35;
+            grid.scrollTop = Math.max(0, rowIndex * rowHeight - grid.clientHeight / 3);
+        }, rowIndex);
+    },
+    scrollToColumn: async ({ root }, columnIndex) => {
+        await root.evaluate((el, columnIndex) => {
+            const grid = (el.querySelector('[role="grid"]') || el.closest('[role="grid"]') || el);
+            // Try to locate the header cell by aria-colindex (1-based in RDG)
+            const ariaIndex = columnIndex + 1;
+            const header = el.querySelector(`[role="columnheader"][aria-colindex="${ariaIndex}"]`);
+            if (header) {
+                grid.scrollLeft = header.offsetLeft;
+                return;
+            }
+            // Column not visible — estimate from average width of visible headers
+            const headers = [...el.querySelectorAll('[role="columnheader"][aria-colindex]')];
+            if (headers.length > 0) {
+                const avgWidth = headers.reduce((sum, h) => sum + h.offsetWidth, 0) / headers.length;
+                grid.scrollLeft = Math.max(0, columnIndex * avgWidth);
+            }
+        }, columnIndex);
+    },
+};
+/** Default strategies for the RDG2D preset (extends RDG with viewport recovery). */
+const RDG2DDefaultStrategies = Object.assign(Object.assign({}, RDGDefaultStrategies), { viewport: rdg2DViewportStrategy });
+// fallow-ignore-next-line unused-export
+exports.RDG2DStrategies = RDG2DDefaultStrategies;
+/**
+ * Full preset for React Data Grid with 2D virtualization (rows + columns both virtualized).
+ * Use instead of `rdg` when horizontal scrolling causes "could not reach cell" errors.
+ * The viewport strategy detects when a row is evicted by a horizontal scroll and restores it.
+ */
+const RDG2DPreset = Object.assign(Object.assign({}, RDGPreset), { strategies: RDG2DDefaultStrategies });
+exports.RDG2D = Object.defineProperty(RDG2DPreset, 'Strategies', { get: () => exports.RDG2DStrategies, enumerable: false });
+exports.rdg2D = exports.RDG2D;

package/dist/smartRow.js

@@ -304,7 +304,8 @@ const _navigateToCell = async (params) => {
         else {
             navResult = await navigateUntilReached();
         }
-        if (navResult instanceof Object && navResult._isLocator) {
+        // navigateUntilReached may return a Locator it found mid-navigation; duck-type check via .count() (public API) rather than the internal _isLocator flag
+        if (navResult && typeof navResult.count === 'function') {
             const loc = navResult;
             if (await loc.count() > 0)
                 return loc;
@@ -488,7 +489,11 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                         cellResolved = !(await isCellLoading(targetCell, col, smart));
                     }
                     if (!cellResolved) {
-                        (0, debugUtils_1.logDebug)(config, 'verbose', `toJSON: cell "${col}" — still loading after ${cellLoadingTimeout}ms, action: ${onCellLoadingTimeout}`);
+                        (0, debugUtils_1.logDebug)(config, 'verbose', `toJSON: cell "${col}" — still loading after ${cellLoadingTimeout}ms, action: ${typeof onCellLoadingTimeout === 'function' ? 'callback' : onCellLoadingTimeout}`);
+                        if (typeof onCellLoadingTimeout === 'function') {
+                            result[col] = await onCellLoadingTimeout(targetCell, col, smart);
+                            continue;
+                        }
                         if (onCellLoadingTimeout === 'skip') {
                             result[col] = '';
                             continue;

package/dist/strategies/index.d.ts

@@ -23,6 +23,7 @@ export declare const Strategies: {
             nextBulkPages?: number;
             previousBulkPages?: number;
             numberOfPages?: number | ((root: import("@playwright/test").Locator) => number | Promise<number>);
+            detectCurrentPage?: (root: import("@playwright/test").Locator) => number | Promise<number>;
             stabilization?: import("./stabilization").StabilizationStrategy;
             timeout?: number;
         }) => import("../types").PaginationStrategy;

package/dist/strategies/pagination.d.ts

@@ -20,6 +20,7 @@ export declare const PaginationStrategies: {
         nextBulkPages?: number;
         previousBulkPages?: number;
         numberOfPages?: number | ((root: import("@playwright/test").Locator) => number | Promise<number>);
+        detectCurrentPage?: (root: import("@playwright/test").Locator) => number | Promise<number>;
         stabilization?: StabilizationStrategy;
         timeout?: number;
     }) => PaginationStrategy;

package/dist/strategies/pagination.js

@@ -58,6 +58,7 @@ exports.PaginationStrategies = {
             } : undefined,
             nextBulkPages: nextBulk,
             previousBulkPages: prevBulk,
+            detectCurrentPage: options.detectCurrentPage,
         };
     },
     /**

package/dist/typeContext.d.ts

@@ -3,4 +3,4 @@
  * This file is generated by scripts/embed-types.mjs
  * It contains the raw text of types.ts to provide context for LLM prompts.
  */
-export declare const TYPE_CONTEXT = "\n/**\n * Flexible selector type - can be a CSS string, function returning a Locator, or Locator itself.\n * @example\n * // String selector\n * rowSelector: 'tbody tr'\n * \n * // Function selector\n * headerSelector: (root) => root.locator('[role=\"columnheader\"]')\n */\nexport type Selector = string | ((root: Locator | Page) => Locator) | ((root: Locator) => Locator);\n\n/**\n * Value used to filter rows.\n * - string/number/RegExp: filter by text content of the cell.\n * - function: filter by custom locator logic within the cell.\n * @example\n * // Text filter\n * { Name: 'John' }\n * \n * // Custom locator filter (e.g. checkbox is checked)\n * { Status: (cell) => cell.locator('input:checked') }\n */\nexport type FilterValue = string | RegExp | number | ((cell: Locator) => Locator);\n\n/**\n * Function to get a cell locator given row, column info.\n * Replaces the old cellResolver.\n */\nexport type GetCellLocatorFn = (args: {\n  row: Locator;\n  /** The root locator passed to useTable(). Useful for re-querying stale row locators. */\n  root: Locator;\n  columnName: string;\n  columnIndex: number;\n  rowIndex?: number;\n  page: Page;\n  config: FinalTableConfig<any>;\n}) => Locator;\n\n/**\n * Hook called before each cell value is read in `toJSON` (and `columnOverrides.read`).\n *\n * Use this to scroll off-screen columns into view in **horizontally** virtualized tables,\n * wait for lazy-rendered content (popovers, tooltips, async cell renderers), or perform\n * any other pre-read setup that doesn't involve Y-axis scrolling.\n *\n * ---\n *\n * **\u26A0\uFE0F Y-scroll footgun \u2014 do NOT call `scrollIntoViewIfNeeded()` on row-virtualized grids.**\n *\n * `scrollIntoViewIfNeeded` adjusts *both* scroll axes. On grids that recycle DOM nodes\n * based on the Y position (MUI DataGrid, AG Grid, react-window, etc.) calling it will\n * shift the viewport vertically, unmounting the row you are currently reading and\n * silently returning stale or empty cell values for the remainder of the row.\n *\n * Safe uses:\n * - Column-only (X-axis) virtualization where rows are always in the DOM.\n * - Calling `scrollIntoViewIfNeeded` on the **header cell** only, when that header is\n *   guaranteed not to trigger a Y-scroll (e.g. sticky header grids).\n *\n * For grids with **both** row and column virtualization, use the `viewport` strategy\n * instead \u2014 it drives explicit `scrollToRow` / `scrollToColumn` calls and is aware of\n * the virtualization lifecycle.\n *\n * @example\n * // Safe: column-only horizontal virtualization (rows always in DOM)\n * strategies: {\n *   beforeCellRead: async ({ columnName, getHeaderCell }) => {\n *     const header = await getHeaderCell(columnName);\n *     await header.scrollIntoViewIfNeeded(); // only scrolls X \u2014 rows stay mounted\n *   }\n * }\n *\n * @example\n * // Safe: wait for a lazy-rendered popover/tooltip before reading its text\n * strategies: {\n *   beforeCellRead: async ({ cell }) => {\n *     await cell.hover();\n *     await cell.page().waitForSelector('.cell-tooltip', { state: 'visible' });\n *   }\n * }\n */\nexport type BeforeCellReadFn = (args: {\n  /** The resolved cell locator */\n  cell: Locator;\n  columnName: string;\n  columnIndex: number;\n  row: Locator;\n  page: Page;\n  root: Locator;\n  /** Resolves a column name to its header cell locator */\n  getHeaderCell: (columnName: string) => Promise<Locator>;\n}) => Promise<void>;\n\n/**\n * Function to get the currently active/focused cell.\n * Returns null if no cell is active.\n */\nexport type GetActiveCellFn = (args: TableContext) => Promise<{\n  rowIndex: number;\n  columnIndex: number;\n  columnName?: string;\n  locator: Locator;\n} | null>;\n\n/**\n * Viewport oracle strategies for virtualized tables.\n *\n * These tell the library *what is currently in the DOM* rather than *how to move*.\n * When present, the cell-reading engine uses them to jump directly to a target\n * row/column instead of stepping blindly with navigation primitives.\n *\n * This is the primary fix for the 2D scroll hazard: scrolling right to bring a\n * column into view can knock rows out of the vertical viewport (and vice versa).\n * With `getVisibleRowRange` the engine detects this and calls `scrollToRow` to\n * restore the row before reading \u2014 eliminating the hazard without polling loops.\n *\n * All members are optional. Supply whichever the underlying grid exposes:\n * - Range oracles alone enable hazard detection with graceful fallback to navigation primitives.\n * - Scroll primitives alone enable direct jumps without range awareness.\n * - Both together give the most reliable, fastest path.\n *\n * @example\n * // MUI DataGrid via apiRef\n * strategies: {\n *   viewport: {\n *     getVisibleRowRange: async ({ root }) =>\n *       root.evaluate(el => {\n *         const api = (el as any).__muiDataGrid__;\n *         return { first: api.getFirstVisibleRow(), last: api.getLastVisibleRow() };\n *       }),\n *     scrollToRow: async ({ root }, rowIndex) =>\n *       root.evaluate((el, idx) =>\n *         (el as any).__muiDataGrid__.scrollToIndexes({ rowIndex: idx }), rowIndex),\n *     scrollToColumn: async ({ root }, colIndex) =>\n *       root.evaluate((el, idx) =>\n *         (el as any).__muiDataGrid__.scrollToIndexes({ colIndex: idx }), colIndex),\n *   }\n * }\n *\n * @example\n * // aria-rowindex / aria-colindex DOM fallback (works without internal API access)\n * strategies: {\n *   viewport: {\n *     getVisibleRowRange: async ({ root }) =>\n *       root.evaluate(el => {\n *         const rows = [...el.querySelectorAll('[role=\"row\"][aria-rowindex]')];\n *         const idxs = rows.map(r => Number(r.getAttribute('aria-rowindex')) - 1);\n *         return { first: Math.min(...idxs), last: Math.max(...idxs) };\n *       }),\n *   }\n * }\n */\nexport interface ViewportStrategy {\n  /**\n   * Returns the 0-based index range of rows currently rendered in the DOM.\n   * Used to detect when a target row has been scrolled out of view and needs recovery.\n   */\n  getVisibleRowRange?: (context: TableContext) => Promise<{ first: number; last: number }>;\n\n  /**\n   * Returns the 0-based index range of columns currently rendered in the DOM.\n   * Used to detect when a target column is not yet mounted before reading.\n   */\n  getVisibleColumnRange?: (context: TableContext) => Promise<{ first: number; last: number }>;\n\n  /**\n   * Scrolls or jumps directly to make a row visible by 0-based index.\n   * Replaces blind goDown()/goUp() step loops for grids that expose a scroll API.\n   */\n  scrollToRow?: (context: TableContext, rowIndex: number) => Promise<void>;\n\n  /**\n   * Scrolls or jumps directly to make a column visible by 0-based index.\n   * Replaces blind goRight()/goLeft() step loops for grids that expose a scroll API.\n   */\n  scrollToColumn?: (context: TableContext, colIndex: number) => Promise<void>;\n\n  /**\n   * When true, disables the automatic memoization of getVisibleColumnRange and\n   * getVisibleRowRange results. By default the library caches each range value and\n   * invalidates it after the corresponding scroll call, eliminating redundant DOM\n   * evaluate() round-trips between scrolls.\n   */\n  disableCache?: boolean;\n}\n\n\n/**\n * SmartCell - A Playwright Locator with table-aware methods for single-cell operations.\n * \n * Extends all standard Locator methods (click, isVisible, etc.).\n */\nexport type SmartCell = Locator & {\n  /**\n   * Scrolls/paginates to bring this specific cell into view using the configured strategies.\n   * Useful when the grid is horizontally virtualized and the column must be scrolled\n   * into view before it can be interacted with or read.\n   */\n  bringIntoView(): Promise<void>;\n};\n\n\n/**\n * SmartRow - A Playwright Locator with table-aware methods.\n * \n * Extends all standard Locator methods (click, isVisible, etc.) with table-specific functionality.\n * \n * @example\n * const row = table.getRow({ Name: 'John Doe' });\n * await row.click(); // Standard Locator method\n * const email = row.getCell('Email'); // Table-aware method\n * const data = await row.toJSON(); // Extract all row data\n * await row.smartFill({ Name: 'Jane', Status: 'Active' }); // Fill form fields\n */\nexport type SmartRow<T = any> = Locator & {\n  /** Optional row index (0-based) if known */\n  rowIndex?: number;\n\n  /** Optional page index this row was found on (0-based) */\n  tablePageIndex?: number;\n\n  /** Reference to the parent TableResult */\n  table: TableResult<T>;\n\n  /**\n   * Get a cell locator by column name.\n   * @param column - Column name (case-sensitive)\n   * @returns SmartCell (Locator + bringIntoView)\n   * @example\n   * const emailCell = row.getCell('Email');\n   * await emailCell.bringIntoView();\n   * await expect(emailCell).toHaveText('john@example.com');\n   */\n  getCell(column: string): SmartCell;\n\n  /**\n   * Extract all cell data as a key-value object.\n   * @param options - Optional configuration\n   * @param options.columns - Specific columns to extract (extracts all if not specified)\n   * @returns Promise resolving to row data\n   * @example\n   * const data = await row.toJSON();\n   * // { Name: 'John', Email: 'john@example.com', ... }\n   * \n   * const partial = await row.toJSON({ columns: ['Name', 'Email'] });\n   * // { Name: 'John', Email: 'john@example.com' }\n   */\n  toJSON(options?: { columns?: string[] }): Promise<T>;\n\n  /**\n   * Scrolls/paginates to bring this row into view.\n   * Works when row position metadata is known (e.g., from getRowByIndex, findRow,\n   * findRows, filter, or async iteration).\n   * @throws Error if row position metadata is unknown\n   */\n  bringIntoView(): Promise<void>;\n\n  /**\n   * Intelligently fills form fields in the row.\n   * Automatically detects input types (text, select, checkbox, contenteditable).\n   * \n   * @param data - Column-value pairs to fill\n   * @param options - Optional configuration\n   * @param options.inputMappers - Custom input selectors per column\n   * @example\n   * // Auto-detection\n   * await row.smartFill({ Name: 'John', Status: 'Active', Subscribe: true });\n   * \n   * // Custom input mappers\n   * await row.smartFill(\n   *   { Name: 'John' },\n   *   { inputMappers: { Name: (cell) => cell.locator('.custom-input') } }\n   * );\n   */\n  smartFill: (data: Partial<T> | Record<string, any>, options?: FillOptions) => Promise<void>;\n\n  /**\n   * Returns whether the row exists in the DOM (i.e. is not a sentinel row).\n   */\n  wasFound(): boolean;\n};\n\nexport type StrategyContext = TableContext & {\n  rowLocator?: Locator;\n  rowIndex?: number;\n};\n\n/**\n * Defines the contract for a sorting strategy.\n */\nexport interface SortingStrategy {\n  /**\n   * Performs the sort action on a column.\n   */\n  doSort(options: {\n    columnName: string;\n    direction: 'asc' | 'desc';\n    context: StrategyContext;\n  }): Promise<void>;\n\n  /**\n   * Retrieves the current sort state of a column.\n   */\n  getSortState(options: {\n    columnName: string;\n    context: StrategyContext;\n  }): Promise<'asc' | 'desc' | 'none'>;\n}\n\n/**\n * Debug configuration for development and troubleshooting\n */\nexport type DebugConfig = {\n  /**\n   * Slow down operations for debugging\n   * - number: Apply same delay to all operations (ms)\n   * - object: Granular delays per operation type\n   */\n  slow?: number | {\n    pagination?: number;\n    getCell?: number;\n    findRow?: number;\n    default?: number;\n  };\n  /**\n   * Log level for debug output\n   * - 'verbose': All logs (verbose, info, error)\n   * - 'info': Info and error logs only\n   * - 'error': Error logs only\n   * - 'none': No logs\n   */\n  logLevel?: 'verbose' | 'info' | 'error' | 'none';\n};\n\nexport interface TableContext<T = any> {\n  root: Locator;\n  config: FinalTableConfig<T>;\n  page: Page;\n  resolve: (selector: Selector, parent: Locator | Page) => Locator;\n  /** Resolves a column name to its header cell locator. Available after table is initialized. */\n  getHeaderCell?: (columnName: string) => Promise<Locator>;\n  /** Returns all column names in order. Available after table is initialized. */\n  getHeaders?: () => Promise<string[]>;\n  /** Scrolls the table horizontally to bring the given column's header into view. */\n  scrollToColumn?: (columnName: string) => Promise<void>;\n}\n\nexport interface PaginationPrimitives {\n  /** Classic \"Next Page\" or \"Scroll Down\" */\n  goNext?: (context: TableContext) => Promise<boolean>;\n\n  /** Classic \"Previous Page\" or \"Scroll Up\" */\n  goPrevious?: (context: TableContext) => Promise<boolean>;\n\n  /** Bulk skip forward multiple pages at once. Returns number of pages skipped. */\n  goNextBulk?: (context: TableContext) => Promise<boolean | number>;\n\n  /** Bulk skip backward multiple pages at once. Returns number of pages skipped. */\n  goPreviousBulk?: (context: TableContext) => Promise<boolean | number>;\n\n  /** Jump to first page / scroll to top */\n  goToFirst?: (context: TableContext) => Promise<boolean>;\n\n  /** Jump to last page / scroll to bottom */\n  goToLast?: (context: TableContext) => Promise<boolean>;\n\n  /**\n   * Fetch the total number of pages currently available.\n   * Can be used to optimize pagination paths (e.g. jumping to last page and going backwards).\n   */\n  getTotalPages?: (context: TableContext) => Promise<number | null>;\n\n  /**\n   * Jump to specific page index (0-indexed).\n   * Can be full-range (e.g. page number input: any page works) or windowed (e.g. only visible links 6\u201314).\n   * Return false when the page is not reachable in the current UI; the library will step toward the target (goNextBulk/goNext or goPreviousBulk/goPrevious) and retry goToPage until it succeeds.\n   */\n  goToPage?: (pageIndex: number, context: TableContext) => Promise<boolean>;\n\n  /** How many pages one goNextBulk() advances. Used by navigation path planner for optimal bringIntoView. */\n  nextBulkPages?: number;\n\n  /** How many pages one goPreviousBulk() goes back. Used by navigation path planner for optimal bringIntoView. */\n  previousBulkPages?: number;\n\n  /**\n   * Called once during init() to sync the library's page counter with the actual DOM state.\n   * Use when a table may open on a page other than the first (e.g. a deep-linked URL that\n   * lands on page 5). Returns a 0-indexed page number.\n   * @example\n   * detectCurrentPage: async (root) => {\n   *   const text = await root.locator('[aria-current=\"page\"]').textContent();\n   *   return parseInt(text ?? '1') - 1;\n   * }\n   */\n  detectCurrentPage?: (root: import('@playwright/test').Locator) => number | Promise<number>;\n}\n\nexport type PaginationStrategy = PaginationPrimitives;\n\nexport type DedupeStrategy = (row: SmartRow) => string | number | Promise<string | number>;\n\n\n\nexport type FillStrategy = (options: {\n  row: SmartRow;\n  columnName: string;\n  value: any;\n  index: number;\n  page: Page;\n  rootLocator: Locator;\n  config: FinalTableConfig<any>;\n  table: TableResult; // The parent table instance\n  fillOptions?: FillOptions;\n}) => Promise<void>;\n\nexport interface ColumnOverride<TValue = any> {\n  /** \n   * How to extract the value from the cell.\n   * `context` provides access to the parent row, permitting multi-cell logic or bypassing the default cell locator.\n   */\n  read?: (cell: Locator) => Promise<TValue> | TValue;\n\n  /** \n   * How to fill the cell with a new value. (Replaces smartFill default logic)\n   * Provides the current value (via `read`) if a `write` wants to check state first.\n   */\n  write?: (params: {\n    cell: Locator;\n    targetValue: TValue;\n    currentValue?: TValue;\n    row: SmartRow<any>;\n  }) => Promise<void>;\n}\n\nexport type { HeaderStrategy } from './strategies/headers';\n\n/**\n * Strategy to resolve column names (string or regex) to their index.\n */\n// fallow-ignore-next-line unused-type\nexport type { ColumnResolutionStrategy } from './strategies/resolution';\n\n/**\n * Strategy to filter rows based on criteria. Applied when using getRow/findRow/findRows with filters.\n * The default engine handles string, RegExp, number, and function (cell) => Locator filters.\n */\nexport interface FilterStrategy {\n  apply(options: {\n    rows: Locator;\n    filter: { column: string, value: FilterValue };\n    colIndex: number;\n    tableContext: TableContext;\n  }): Locator;\n}\n\n/**\n * Strategy to check if the table or rows are loading. Used after pagination/sort to wait for content.\n * E.g. isHeaderLoading for init stability; isTableLoading after sort/pagination.\n */\nexport interface LoadingStrategy {\n  isTableLoading?: (context: TableContext) => Promise<boolean>;\n  isRowLoading?: (row: SmartRow) => Promise<boolean>;\n  isHeaderLoading?: (context: TableContext) => Promise<boolean>;\n\n  /**\n   * How long (ms) to wait for a loading row to resolve before applying onRowLoadingTimeout.\n   * When not set, loading rows are immediately skipped (backward-compatible behavior).\n   */\n  rowLoadingTimeout?: number;\n\n  /**\n   * What to do when a row is still loading after rowLoadingTimeout ms.\n   * - 'skip': drop the row from results (matches legacy skip behavior)\n   * - 'read-as-is': include the row even though it's still loading (default)\n   * - 'throw': throw an error with row index and timeout info\n   * Defaults to 'read-as-is' when rowLoadingTimeout is set.\n   */\n  onRowLoadingTimeout?: 'skip' | 'read-as-is' | 'throw';\n\n  /**\n   * Predicate called before reading each cell. Return true if the cell is still loading.\n   * When cellLoadingTimeout is also set, the engine waits up to that many ms for the\n   * cell to resolve before applying onCellLoadingTimeout.\n   */\n  isCellLoading?: (cell: import('@playwright/test').Locator, columnName: string, row: SmartRow) => Promise<boolean>;\n\n  /**\n   * How long (ms) to wait for a loading cell to resolve before applying onCellLoadingTimeout.\n   * When not set and isCellLoading returns true, the cell is read as-is immediately.\n   */\n  cellLoadingTimeout?: number;\n\n  /**\n   * What to do when a cell is still loading after cellLoadingTimeout ms.\n   * - 'skip': use empty string for this cell value\n   * - 'read-as-is': read the cell content even though it's still loading (default)\n   * - 'throw': throw an error with column name, row index and timeout info\n   * Defaults to 'read-as-is' when cellLoadingTimeout is set.\n   */\n  onCellLoadingTimeout?: 'skip' | 'read-as-is' | 'throw';\n}\n\n/**\n * Organized container for all table interaction strategies.\n */\nexport interface TableStrategies {\n  /** Strategy for discovering/scanning headers */\n  header?: HeaderStrategy;\n  /** Primitive navigation functions (goUp, goDown, goLeft, goRight, goHome) */\n  navigation?: NavigationPrimitives;\n\n  /** Strategy for filling form inputs */\n  fill?: FillStrategy;\n  /** Strategy for paginating through data */\n  pagination?: PaginationStrategy;\n  /** Strategy for sorting columns */\n  sorting?: SortingStrategy;\n  /** Strategy for deduplicating rows during iteration/scrolling */\n  dedupe?: DedupeStrategy;\n  /** Function to get a cell locator */\n  getCellLocator?: GetCellLocatorFn;\n  /** Function to get the currently active/focused cell */\n  getActiveCell?: GetActiveCellFn;\n  /**\n   * Strategy for filtering rows. If present, FilterEngine will delegate filter application\n   * to this pluggable strategy.\n   */\n  filter?: FilterStrategy;\n  /**\n   * Hook called before each cell value is read in toJSON and columnOverrides.read.\n   * Fires for both the default innerText extraction and custom read mappers.\n   * Useful for scrolling off-screen columns into view in horizontally virtualized tables.\n   */\n  beforeCellRead?: BeforeCellReadFn;\n  /**\n   * Strategy for detecting loading states. Use this for table-, row-, and header-level readiness.\n   * E.g. after sort/pagination, the engine uses loading.isTableLoading when present.\n   */\n  loading?: LoadingStrategy;\n\n  /**\n   * Viewport oracle strategies for 2D virtualized tables (e.g. MUI DataGrid, AG Grid,\n   * Braintrust-style grids where both rows and columns are virtualized simultaneously).\n   *\n   * When present, the cell-reading engine uses these to jump directly to the target\n   * row/column and to detect the 2D scroll hazard (scrolling to reveal a column can\n   * knock rows out of the vertical viewport, and vice versa).\n   *\n   * Completely optional and additive \u2014 existing `navigation` primitives remain the fallback.\n   */\n  viewport?: ViewportStrategy;\n}\n\n\nexport interface TableConfig<T = any> {\n  /** Selector for the table headers */\n  headerSelector?: string | ((root: Locator) => Locator);\n  /** Selector for the table rows */\n  rowSelector?: string;\n  /** Selector for the cells within a row */\n  cellSelector?: string | ((row: Locator) => Locator);\n  /** Number of pages to scan for verification */\n  maxPages?: number;\n  /**\n   * Default concurrency strategy for iteration methods.\n   * Can be overridden by the options passed to forEach, map, or filter.\n   */\n  concurrency?: RowIterationMode;\n  /** Hook to rename columns dynamically */\n  headerTransformer?: (args: { text: string, index: number, locator: Locator, seenHeaders: Set<string> }) => string | Promise<string>;\n  /** Automatically scroll to table on init */\n  autoScroll?: boolean;\n  /** Debug options for development and troubleshooting */\n  debug?: DebugConfig;\n  /** Reset hook */\n  onReset?: (context: TableContext) => Promise<void>;\n  /** All interaction strategies */\n  strategies?: TableStrategies;\n\n  /**\n   * Unified interface for reading and writing data to specific columns.\n   * Overrides both default extraction (toJSON) and filling (smartFill) logic.\n   */\n  columnOverrides?: Partial<Record<keyof T, ColumnOverride<T[keyof T]>>>;\n}\n\nexport interface FinalTableConfig<T = any> extends TableConfig<T> {\n  headerSelector: string | ((root: Locator) => Locator);\n  rowSelector: string;\n  cellSelector: string | ((row: Locator) => Locator);\n  maxPages: number;\n  autoScroll: boolean;\n  concurrency?: RowIterationMode;\n  debug?: TableConfig['debug'];\n  headerTransformer: (args: { text: string, index: number, locator: Locator, seenHeaders: Set<string> }) => string | Promise<string>;\n  onReset: (context: TableContext) => Promise<void>;\n  strategies: TableStrategies;\n}\n\n\nexport interface FillOptions {\n  /**\n   * Custom input mappers for specific columns.\n   * Maps column names to functions that return the input locator for that cell.\n   */\n  inputMappers?: Record<string, (cell: Locator) => Locator>;\n}\n\n\n\n/** Callback context passed to forEach, map, and filter. */\nexport type RowIterationContext<T = any> = {\n  row: SmartRow<T>;\n  /** 0-based iteration counter \u2014 the order this row was visited, not its DOM position or grid identity. @deprecated Use `index` instead. `rowIndex` will be removed in v7.0.0. */\n  rowIndex: number;\n  /** 0-based iteration counter \u2014 the order this row was visited, not its DOM position or grid identity. */\n  index: number;\n  /** 0-based page index \u2014 which page this row was collected from. */\n  pageIndex: number;\n  stop: () => void;\n};\n\n/** Concurrency modes for row iteration. */\nexport type RowIterationMode = 'parallel' | 'sequential' | 'synchronized';\n\n/** Shared options for forEach, map, and filter. */\nexport type RowIterationOptions = {\n  /** Maximum number of pages to iterate. Defaults to config.maxPages. */\n  maxPages?: number;\n  /**\n   * Concurrency strategy for iteration.\n   * - 'parallel': Full parallel execution of both navigation and actions.\n   * - 'synchronized': Parallel navigation (lock-step) with serial actions.\n   * - 'sequential': Strictly serial one-at-a-time execution. No parallel navigation.\n   * @default 'parallel' (for map), 'sequential' (for forEach/filter)\n   */\n  concurrency?: RowIterationMode;\n  /**\n   * Deduplication strategy. Use when rows may repeat across iterations\n   * (e.g. infinite scroll tables). Returns a unique key per row.\n   */\n  dedupe?: DedupeStrategy;\n  /**\n   * When true, use goNextBulk (if present) to advance pages during iteration.\n   * @default false \u2014 uses goNext for one-page-at-a-time advancement\n   */\n  useBulkPagination?: boolean;\n};\n\nexport interface TableResult<T = any> extends AsyncIterable<{ row: SmartRow<T>; rowIndex: number; index: number; pageIndex: number }> {\n  /**\n   * Represents the current page index of the table's DOM.\n   * Starts at 0. Automatically maintained by the library during pagination and bringIntoView.\n   */\n  currentPageIndex: number;\n\n  /**\n   * Initializes the table by resolving headers. Must be called before using sync methods.\n   * @param options Optional timeout for header resolution (default: 3000ms)\n   */\n  init(options?: { timeout?: number }): Promise<TableResult<T>>;\n\n  /**\n   * SYNC: Checks if the table has been initialized.\n   * @returns true if init() has been called and completed, false otherwise\n   */\n  isInitialized(): boolean;\n\n  getHeaders: () => Promise<string[]>;\n  getHeaderCell: (columnName: string) => Promise<Locator>;\n\n  /**\n   * Finds a row by filters on the current page only. Returns immediately (sync).\n   * Throws error if table is not initialized.\n   * @note The returned SmartRow may have `rowIndex` as 0 when the match is not the first row.\n   * Use getRowByIndex(index) when you need a known index (e.g. for bringIntoView()).\n   */\n  getRow: (\n    filters: Record<string, FilterValue>,\n    options?: { exact?: boolean }\n  ) => SmartRow<T>;\n\n  /**\n   * Gets a row by 0-based index on the current page.\n   * Throws error if table is not initialized.\n   * @param index 0-based row index\n   */\n  getRowByIndex: (\n    index: number\n  ) => SmartRow<T>;\n\n  /**\n   * ASYNC: Searches for a single row across pages using pagination.\n   * Auto-initializes the table if not already initialized.\n   * @param filters - The filter criteria to match\n   * @param options - Search options including exact match and max pages\n   */\n  findRow: (\n    filters: Record<string, FilterValue>,\n    options?: { exact?: boolean, maxPages?: number }\n  ) => Promise<SmartRow<T>>;\n\n  /**\n   * ASYNC: Searches for all matching rows across pages using pagination.\n   * Auto-initializes the table if not already initialized.\n   * @param filters - The filter criteria to match (omit or pass {} for all rows)\n   * @param options - Search options including exact match and max pages\n   */\n  findRows: (\n    filters?: Record<string, FilterValue>,\n    options?: { exact?: boolean, maxPages?: number, useBulkPagination?: boolean }\n  ) => Promise<SmartRowArray<T>>;\n\n  /**\n   * Navigates to a specific column using the configured CellNavigationStrategy.\n   */\n  scrollToColumn: (columnName: string) => Promise<void>;\n\n  /**\n   * Counts the number of rows currently on the page.\n   * Does not paginate.\n   */\n  countRows: () => Promise<number>;\n\n  /**\n   * Iterates over rows and extracts the value of a single column.\n   * More efficient than map + toJSON for single-column extraction.\n   * @param columnName - The name of the column to extract\n   * @param options - Iteration options\n   */\n  mapColumn<R = string>(columnName: string, options?: RowIterationOptions): Promise<R[]>;\n\n  /**\n   * Iterates over rows and extracts the value of a single column as strings.\n   * @param columnName - The name of the column to extract\n   * @param options - Iteration options\n   */\n  getColumnValues(columnName: string, options?: RowIterationOptions): Promise<string[]>;\n\n\n  /**\n   * Resets the table state (clears cache, flags) and invokes the onReset strategy.\n   */\n  reset: () => Promise<void>;\n\n  /**\n   * Revalidates the table's structure (headers, columns) without resetting pagination or state.\n   * Useful when columns change visibility or order dynamically.\n   */\n  revalidate: () => Promise<void>;\n\n  /**\n   * Iterates every row across all pages, calling the callback for side effects.\n   * Execution is sequential by default (safe for interactions like clicking/filling).\n   * Call `stop()` in the callback to end iteration early.\n   *\n   * @param callback - Function receiving { row, rowIndex, stop }\n   * @param options - maxPages, concurrency, dedupe, useBulkPagination\n   *\n   * @example\n   * await table.forEach(async ({ row, stop }) => {\n   *   if (await row.getCell('Status').innerText() === 'Done') stop();\n   *   await row.getCell('Checkbox').click();\n   * });\n   */\n  forEach(\n    callback: (ctx: RowIterationContext<T>) => void | Promise<void>,\n    options?: RowIterationOptions\n  ): Promise<void>;\n\n  /**\n   * Transforms every row across all pages into a value. Returns a flat array.\n   * Execution is parallel within each page by default (safe for reads).\n   * Call `stop()` to halt after the current page finishes.\n   *\n   * > **\u26A0\uFE0F UI Interactions:** `map` defaults to `concurrency: 'parallel'`. If your callback opens popovers,\n   * > fills inputs, or otherwise mutates UI state, pass `concurrency: 'sequential'` (or `'synchronized'`\n   * > when navigation must stay lock-step) to avoid overlapping interactions.\n   *\n   * @param callback - Function receiving { row, rowIndex, stop }\n   * @param options - maxPages, concurrency, dedupe, useBulkPagination\n   *\n   * @example\n   * // Data extraction \u2014 parallel is safe\n   * const emails = await table.map(({ row }) => row.getCell('Email').innerText());\n   *\n   * @example\n   * // UI interactions \u2014 use sequential (or synchronized) concurrency\n   * const assignees = await table.map(async ({ row }) => {\n   *   await row.getCell('Assignee').locator('button').click();\n   *   const name = await page.locator('.popover .name').innerText();\n   *   await page.keyboard.press('Escape');\n   *   return name;\n   * }, { concurrency: 'sequential' });\n   */\n  map<R>(\n    callback: (ctx: RowIterationContext<T>) => R | Promise<R>,\n    options?: RowIterationOptions\n  ): Promise<R[]>;\n\n  /**\n   * Filters rows across all pages by an async predicate. Returns a SmartRowArray.\n   * Rows are returned as-is \u2014 call `bringIntoView()` on each if needed.\n   * Execution is sequential by default.\n   *\n   * @param predicate - Function receiving { row, rowIndex, stop }\n   * @param options - maxPages, concurrency, dedupe, useBulkPagination\n   *\n   * @example\n   * const active = await table.filter(async ({ row }) =>\n   *   await row.getCell('Status').innerText() === 'Active'\n   * );\n   */\n  filter(\n    predicate: (ctx: RowIterationContext<T>) => boolean | Promise<boolean>,\n    options?: RowIterationOptions\n  ): Promise<SmartRowArray<T>>;\n\n  /**\n   * Provides access to sorting actions and assertions.\n   */\n  sorting: {\n    /**\n     * Applies the configured sorting strategy to the specified column.\n     * @param columnName The name of the column to sort.\n     * @param direction The direction to sort ('asc' or 'desc').\n     */\n    apply(columnName: string, direction: 'asc' | 'desc'): Promise<void>;\n    /**\n     * Gets the current sort state of a column using the configured sorting strategy.\n     * @param columnName The name of the column to check.\n     * @returns A promise that resolves to 'asc', 'desc', or 'none'.\n     */\n    getState(columnName: string): Promise<'asc' | 'desc' | 'none'>;\n  };\n\n  /**\n   * Generate an AI-friendly configuration prompt for debugging.\n   * Outputs table HTML and TypeScript definitions to help AI assistants generate config.\n   * Automatically throws an Error containing the prompt.\n   */\n  generateConfig: () => Promise<void>;\n\n  /**\n   * @deprecated Use `generateConfig()` instead. Will be removed in v7.0.0.\n   */\n  generateConfigPrompt: () => Promise<void>;\n}\n";
+export declare const TYPE_CONTEXT = "\n/**\n * Flexible selector type - can be a CSS string, function returning a Locator, or Locator itself.\n * @example\n * // String selector\n * rowSelector: 'tbody tr'\n * \n * // Function selector\n * headerSelector: (root) => root.locator('[role=\"columnheader\"]')\n */\nexport type Selector = string | ((root: Locator | Page) => Locator) | ((root: Locator) => Locator);\n\n/**\n * Value used to filter rows.\n * - string/number/RegExp: filter by text content of the cell.\n * - function: filter by custom locator logic within the cell.\n * @example\n * // Text filter\n * { Name: 'John' }\n * \n * // Custom locator filter (e.g. checkbox is checked)\n * { Status: (cell) => cell.locator('input:checked') }\n */\nexport type FilterValue = string | RegExp | number | ((cell: Locator) => Locator);\n\n/**\n * Function to get a cell locator given row, column info.\n * Replaces the old cellResolver.\n */\nexport type GetCellLocatorFn = (args: {\n  row: Locator;\n  /** The root locator passed to useTable(). Useful for re-querying stale row locators. */\n  root: Locator;\n  columnName: string;\n  columnIndex: number;\n  rowIndex?: number;\n  page: Page;\n  config: FinalTableConfig<any>;\n}) => Locator;\n\n/**\n * Hook called before each cell value is read in `toJSON` (and `columnOverrides.read`).\n *\n * Use this to scroll off-screen columns into view in **horizontally** virtualized tables,\n * wait for lazy-rendered content (popovers, tooltips, async cell renderers), or perform\n * any other pre-read setup that doesn't involve Y-axis scrolling.\n *\n * ---\n *\n * **\u26A0\uFE0F Y-scroll footgun \u2014 do NOT call `scrollIntoViewIfNeeded()` on row-virtualized grids.**\n *\n * `scrollIntoViewIfNeeded` adjusts *both* scroll axes. On grids that recycle DOM nodes\n * based on the Y position (MUI DataGrid, AG Grid, react-window, etc.) calling it will\n * shift the viewport vertically, unmounting the row you are currently reading and\n * silently returning stale or empty cell values for the remainder of the row.\n *\n * Safe uses:\n * - Column-only (X-axis) virtualization where rows are always in the DOM.\n * - Calling `scrollIntoViewIfNeeded` on the **header cell** only, when that header is\n *   guaranteed not to trigger a Y-scroll (e.g. sticky header grids).\n *\n * For grids with **both** row and column virtualization, use the `viewport` strategy\n * instead \u2014 it drives explicit `scrollToRow` / `scrollToColumn` calls and is aware of\n * the virtualization lifecycle.\n *\n * @example\n * // Safe: column-only horizontal virtualization (rows always in DOM)\n * strategies: {\n *   beforeCellRead: async ({ columnName, getHeaderCell }) => {\n *     const header = await getHeaderCell(columnName);\n *     await header.scrollIntoViewIfNeeded(); // only scrolls X \u2014 rows stay mounted\n *   }\n * }\n *\n * @example\n * // Safe: wait for a lazy-rendered popover/tooltip before reading its text\n * strategies: {\n *   beforeCellRead: async ({ cell }) => {\n *     await cell.hover();\n *     await cell.page().waitForSelector('.cell-tooltip', { state: 'visible' });\n *   }\n * }\n */\nexport type BeforeCellReadFn = (args: {\n  /** The resolved cell locator */\n  cell: Locator;\n  columnName: string;\n  columnIndex: number;\n  row: Locator;\n  page: Page;\n  root: Locator;\n  /** Resolves a column name to its header cell locator */\n  getHeaderCell: (columnName: string) => Promise<Locator>;\n}) => Promise<void>;\n\n/**\n * Function to get the currently active/focused cell.\n * Returns null if no cell is active.\n */\nexport type GetActiveCellFn = (args: TableContext) => Promise<{\n  rowIndex: number;\n  columnIndex: number;\n  columnName?: string;\n  locator: Locator;\n} | null>;\n\n/**\n * Viewport oracle strategies for virtualized tables.\n *\n * These tell the library *what is currently in the DOM* rather than *how to move*.\n * When present, the cell-reading engine uses them to jump directly to a target\n * row/column instead of stepping blindly with navigation primitives.\n *\n * This is the primary fix for the 2D scroll hazard: scrolling right to bring a\n * column into view can knock rows out of the vertical viewport (and vice versa).\n * With `getVisibleRowRange` the engine detects this and calls `scrollToRow` to\n * restore the row before reading \u2014 eliminating the hazard without polling loops.\n *\n * All members are optional. Supply whichever the underlying grid exposes:\n * - Range oracles alone enable hazard detection with graceful fallback to navigation primitives.\n * - Scroll primitives alone enable direct jumps without range awareness.\n * - Both together give the most reliable, fastest path.\n *\n * @example\n * // MUI DataGrid via apiRef\n * strategies: {\n *   viewport: {\n *     getVisibleRowRange: async ({ root }) =>\n *       root.evaluate(el => {\n *         const api = (el as any).__muiDataGrid__;\n *         return { first: api.getFirstVisibleRow(), last: api.getLastVisibleRow() };\n *       }),\n *     scrollToRow: async ({ root }, rowIndex) =>\n *       root.evaluate((el, idx) =>\n *         (el as any).__muiDataGrid__.scrollToIndexes({ rowIndex: idx }), rowIndex),\n *     scrollToColumn: async ({ root }, colIndex) =>\n *       root.evaluate((el, idx) =>\n *         (el as any).__muiDataGrid__.scrollToIndexes({ colIndex: idx }), colIndex),\n *   }\n * }\n *\n * @example\n * // aria-rowindex / aria-colindex DOM fallback (works without internal API access)\n * strategies: {\n *   viewport: {\n *     getVisibleRowRange: async ({ root }) =>\n *       root.evaluate(el => {\n *         const rows = [...el.querySelectorAll('[role=\"row\"][aria-rowindex]')];\n *         const idxs = rows.map(r => Number(r.getAttribute('aria-rowindex')) - 1);\n *         return { first: Math.min(...idxs), last: Math.max(...idxs) };\n *       }),\n *   }\n * }\n */\nexport interface ViewportStrategy {\n  /**\n   * Returns the 0-based index range of rows currently rendered in the DOM.\n   * Used to detect when a target row has been scrolled out of view and needs recovery.\n   */\n  getVisibleRowRange?: (context: TableContext) => Promise<{ first: number; last: number }>;\n\n  /**\n   * Returns the 0-based index range of columns currently rendered in the DOM.\n   * Used to detect when a target column is not yet mounted before reading.\n   */\n  getVisibleColumnRange?: (context: TableContext) => Promise<{ first: number; last: number }>;\n\n  /**\n   * Scrolls or jumps directly to make a row visible by 0-based index.\n   * Replaces blind goDown()/goUp() step loops for grids that expose a scroll API.\n   */\n  scrollToRow?: (context: TableContext, rowIndex: number) => Promise<void>;\n\n  /**\n   * Scrolls or jumps directly to make a column visible by 0-based index.\n   * Replaces blind goRight()/goLeft() step loops for grids that expose a scroll API.\n   */\n  scrollToColumn?: (context: TableContext, colIndex: number) => Promise<void>;\n\n  /**\n   * When true, disables the automatic memoization of getVisibleColumnRange and\n   * getVisibleRowRange results. By default the library caches each range value and\n   * invalidates it after the corresponding scroll call, eliminating redundant DOM\n   * evaluate() round-trips between scrolls.\n   */\n  disableCache?: boolean;\n}\n\n\n/**\n * SmartCell - A Playwright Locator with table-aware methods for single-cell operations.\n * \n * Extends all standard Locator methods (click, isVisible, etc.).\n */\nexport type SmartCell = Locator & {\n  /**\n   * Scrolls/paginates to bring this specific cell into view using the configured strategies.\n   * Useful when the grid is horizontally virtualized and the column must be scrolled\n   * into view before it can be interacted with or read.\n   */\n  bringIntoView(): Promise<void>;\n};\n\n\n/**\n * SmartRow - A Playwright Locator with table-aware methods.\n * \n * Extends all standard Locator methods (click, isVisible, etc.) with table-specific functionality.\n * \n * @example\n * const row = table.getRow({ Name: 'John Doe' });\n * await row.click(); // Standard Locator method\n * const email = row.getCell('Email'); // Table-aware method\n * const data = await row.toJSON(); // Extract all row data\n * await row.smartFill({ Name: 'Jane', Status: 'Active' }); // Fill form fields\n */\nexport type SmartRow<T = any> = Locator & {\n  /** Optional row index (0-based) if known */\n  rowIndex?: number;\n\n  /** Optional page index this row was found on (0-based) */\n  tablePageIndex?: number;\n\n  /** Reference to the parent TableResult */\n  table: TableResult<T>;\n\n  /**\n   * Get a cell locator by column name.\n   * @param column - Column name (case-sensitive)\n   * @returns SmartCell (Locator + bringIntoView)\n   * @example\n   * const emailCell = row.getCell('Email');\n   * await emailCell.bringIntoView();\n   * await expect(emailCell).toHaveText('john@example.com');\n   */\n  getCell(column: string): SmartCell;\n\n  /**\n   * Extract all cell data as a key-value object.\n   * @param options - Optional configuration\n   * @param options.columns - Specific columns to extract (extracts all if not specified)\n   * @returns Promise resolving to row data\n   * @example\n   * const data = await row.toJSON();\n   * // { Name: 'John', Email: 'john@example.com', ... }\n   * \n   * const partial = await row.toJSON({ columns: ['Name', 'Email'] });\n   * // { Name: 'John', Email: 'john@example.com' }\n   */\n  toJSON(options?: { columns?: string[] }): Promise<T>;\n\n  /**\n   * Scrolls/paginates to bring this row into view.\n   * Works when row position metadata is known (e.g., from getRowByIndex, findRow,\n   * findRows, filter, or async iteration).\n   * @throws Error if row position metadata is unknown\n   */\n  bringIntoView(): Promise<void>;\n\n  /**\n   * Intelligently fills form fields in the row.\n   * Automatically detects input types (text, select, checkbox, contenteditable).\n   * \n   * @param data - Column-value pairs to fill\n   * @param options - Optional configuration\n   * @param options.inputMappers - Custom input selectors per column\n   * @example\n   * // Auto-detection\n   * await row.smartFill({ Name: 'John', Status: 'Active', Subscribe: true });\n   * \n   * // Custom input mappers\n   * await row.smartFill(\n   *   { Name: 'John' },\n   *   { inputMappers: { Name: (cell) => cell.locator('.custom-input') } }\n   * );\n   */\n  smartFill: (data: Partial<T> | Record<string, any>, options?: FillOptions) => Promise<void>;\n\n  /**\n   * Returns whether the row exists in the DOM (i.e. is not a sentinel row).\n   */\n  wasFound(): boolean;\n};\n\nexport type StrategyContext = TableContext & {\n  rowLocator?: Locator;\n  rowIndex?: number;\n};\n\n/**\n * Defines the contract for a sorting strategy.\n */\nexport interface SortingStrategy {\n  /**\n   * Performs the sort action on a column.\n   */\n  doSort(options: {\n    columnName: string;\n    direction: 'asc' | 'desc';\n    context: StrategyContext;\n  }): Promise<void>;\n\n  /**\n   * Retrieves the current sort state of a column.\n   */\n  getSortState(options: {\n    columnName: string;\n    context: StrategyContext;\n  }): Promise<'asc' | 'desc' | 'none'>;\n}\n\n/**\n * Debug configuration for development and troubleshooting\n */\nexport type DebugConfig = {\n  /**\n   * Slow down operations for debugging\n   * - number: Apply same delay to all operations (ms)\n   * - object: Granular delays per operation type\n   */\n  slow?: number | {\n    pagination?: number;\n    getCell?: number;\n    findRow?: number;\n    default?: number;\n  };\n  /**\n   * Log level for debug output\n   * - 'verbose': All logs (verbose, info, error)\n   * - 'info': Info and error logs only\n   * - 'error': Error logs only\n   * - 'none': No logs\n   */\n  logLevel?: 'verbose' | 'info' | 'error' | 'none';\n};\n\nexport interface TableContext<T = any> {\n  root: Locator;\n  config: FinalTableConfig<T>;\n  page: Page;\n  resolve: (selector: Selector, parent: Locator | Page) => Locator;\n  /** Resolves a column name to its header cell locator. Available after table is initialized. */\n  getHeaderCell?: (columnName: string) => Promise<Locator>;\n  /** Returns all column names in order. Available after table is initialized. */\n  getHeaders?: () => Promise<string[]>;\n  /** Scrolls the table horizontally to bring the given column's header into view. */\n  scrollToColumn?: (columnName: string) => Promise<void>;\n}\n\nexport interface PaginationPrimitives {\n  /** Classic \"Next Page\" or \"Scroll Down\" */\n  goNext?: (context: TableContext) => Promise<boolean>;\n\n  /** Classic \"Previous Page\" or \"Scroll Up\" */\n  goPrevious?: (context: TableContext) => Promise<boolean>;\n\n  /** Bulk skip forward multiple pages at once. Returns number of pages skipped. */\n  goNextBulk?: (context: TableContext) => Promise<boolean | number>;\n\n  /** Bulk skip backward multiple pages at once. Returns number of pages skipped. */\n  goPreviousBulk?: (context: TableContext) => Promise<boolean | number>;\n\n  /** Jump to first page / scroll to top */\n  goToFirst?: (context: TableContext) => Promise<boolean>;\n\n  /** Jump to last page / scroll to bottom */\n  goToLast?: (context: TableContext) => Promise<boolean>;\n\n  /**\n   * Fetch the total number of pages currently available.\n   * Can be used to optimize pagination paths (e.g. jumping to last page and going backwards).\n   */\n  getTotalPages?: (context: TableContext) => Promise<number | null>;\n\n  /**\n   * Jump to specific page index (0-indexed).\n   * Can be full-range (e.g. page number input: any page works) or windowed (e.g. only visible links 6\u201314).\n   * Return false when the page is not reachable in the current UI; the library will step toward the target (goNextBulk/goNext or goPreviousBulk/goPrevious) and retry goToPage until it succeeds.\n   */\n  goToPage?: (pageIndex: number, context: TableContext) => Promise<boolean>;\n\n  /** How many pages one goNextBulk() advances. Used by navigation path planner for optimal bringIntoView. */\n  nextBulkPages?: number;\n\n  /** How many pages one goPreviousBulk() goes back. Used by navigation path planner for optimal bringIntoView. */\n  previousBulkPages?: number;\n\n  /**\n   * Called once during init() to sync the library's page counter with the actual DOM state.\n   * Use when a table may open on a page other than the first (e.g. a deep-linked URL that\n   * lands on page 5). Returns a 0-indexed page number.\n   * @example\n   * detectCurrentPage: async (root) => {\n   *   const text = await root.locator('[aria-current=\"page\"]').textContent();\n   *   return parseInt(text ?? '1') - 1;\n   * }\n   */\n  detectCurrentPage?: (root: import('@playwright/test').Locator) => number | Promise<number>;\n}\n\nexport type PaginationStrategy = PaginationPrimitives;\n\nexport type DedupeStrategy = (row: SmartRow) => string | number | Promise<string | number>;\n\n\n\nexport type FillStrategy = (options: {\n  row: SmartRow;\n  columnName: string;\n  value: any;\n  index: number;\n  page: Page;\n  rootLocator: Locator;\n  config: FinalTableConfig<any>;\n  table: TableResult; // The parent table instance\n  fillOptions?: FillOptions;\n}) => Promise<void>;\n\nexport interface ColumnOverride<TValue = any> {\n  /** \n   * How to extract the value from the cell.\n   * `context` provides access to the parent row, permitting multi-cell logic or bypassing the default cell locator.\n   */\n  read?: (cell: Locator) => Promise<TValue> | TValue;\n\n  /** \n   * How to fill the cell with a new value. (Replaces smartFill default logic)\n   * Provides the current value (via `read`) if a `write` wants to check state first.\n   */\n  write?: (params: {\n    cell: Locator;\n    targetValue: TValue;\n    currentValue?: TValue;\n    row: SmartRow<any>;\n  }) => Promise<void>;\n}\n\nexport type { HeaderStrategy } from './strategies/headers';\n\n/**\n * Strategy to resolve column names (string or regex) to their index.\n */\n// fallow-ignore-next-line unused-type\nexport type { ColumnResolutionStrategy } from './strategies/resolution';\n\n/**\n * Strategy to filter rows based on criteria. Applied when using getRow/findRow/findRows with filters.\n * The default engine handles string, RegExp, number, and function (cell) => Locator filters.\n */\nexport interface FilterStrategy {\n  apply(options: {\n    rows: Locator;\n    filter: { column: string, value: FilterValue };\n    colIndex: number;\n    tableContext: TableContext;\n  }): Locator;\n}\n\n/**\n * Strategy to check if the table or rows are loading. Used after pagination/sort to wait for content.\n * E.g. isHeaderLoading for init stability; isTableLoading after sort/pagination.\n */\nexport interface LoadingStrategy {\n  isTableLoading?: (context: TableContext) => Promise<boolean>;\n  isRowLoading?: (row: SmartRow) => Promise<boolean>;\n  isHeaderLoading?: (context: TableContext) => Promise<boolean>;\n\n  /**\n   * How long (ms) to wait for a loading row to resolve before applying onRowLoadingTimeout.\n   * When not set, loading rows are immediately skipped (backward-compatible behavior).\n   */\n  rowLoadingTimeout?: number;\n\n  /**\n   * What to do when a row is still loading after rowLoadingTimeout ms.\n   * - 'skip': drop the row from results (matches legacy skip behavior)\n   * - 'read-as-is': include the row even though it's still loading (default)\n   * - 'throw': throw an error with row index and timeout info\n   * Defaults to 'read-as-is' when rowLoadingTimeout is set.\n   */\n  onRowLoadingTimeout?: 'skip' | 'read-as-is' | 'throw';\n\n  /**\n   * Predicate called before reading each cell. Return true if the cell is still loading.\n   * When cellLoadingTimeout is also set, the engine waits up to that many ms for the\n   * cell to resolve before applying onCellLoadingTimeout.\n   */\n  isCellLoading?: (cell: import('@playwright/test').Locator, columnName: string, row: SmartRow) => Promise<boolean>;\n\n  /**\n   * How long (ms) to wait for a loading cell to resolve before applying onCellLoadingTimeout.\n   * When not set and isCellLoading returns true, the cell is read as-is immediately.\n   */\n  cellLoadingTimeout?: number;\n\n  /**\n   * What to do when a cell is still loading after cellLoadingTimeout ms.\n   * - 'skip': use empty string for this cell value\n   * - 'read-as-is': read the cell content even though it's still loading (default)\n   * - 'throw': throw an error with column name, row index and timeout info\n   * - callback: called with (cell, columnName, row); its return value becomes the cell's string value\n   * Defaults to 'read-as-is' when cellLoadingTimeout is set.\n   */\n  onCellLoadingTimeout?:\n    | 'skip'\n    | 'read-as-is'\n    | 'throw'\n    | ((cell: import('@playwright/test').Locator, columnName: string, row: SmartRow) => Promise<string>);\n}\n\n/**\n * Organized container for all table interaction strategies.\n */\nexport interface TableStrategies {\n  /** Strategy for discovering/scanning headers */\n  header?: HeaderStrategy;\n  /** Primitive navigation functions (goUp, goDown, goLeft, goRight, goHome) */\n  navigation?: NavigationPrimitives;\n\n  /** Strategy for filling form inputs */\n  fill?: FillStrategy;\n  /** Strategy for paginating through data */\n  pagination?: PaginationStrategy;\n  /** Strategy for sorting columns */\n  sorting?: SortingStrategy;\n  /** Strategy for deduplicating rows during iteration/scrolling */\n  dedupe?: DedupeStrategy;\n  /** Function to get a cell locator */\n  getCellLocator?: GetCellLocatorFn;\n  /** Function to get the currently active/focused cell */\n  getActiveCell?: GetActiveCellFn;\n  /**\n   * Strategy for filtering rows. If present, FilterEngine will delegate filter application\n   * to this pluggable strategy.\n   */\n  filter?: FilterStrategy;\n  /**\n   * Hook called before each cell value is read in toJSON and columnOverrides.read.\n   * Fires for both the default innerText extraction and custom read mappers.\n   * Useful for scrolling off-screen columns into view in horizontally virtualized tables.\n   */\n  beforeCellRead?: BeforeCellReadFn;\n  /**\n   * Strategy for detecting loading states. Use this for table-, row-, and header-level readiness.\n   * E.g. after sort/pagination, the engine uses loading.isTableLoading when present.\n   */\n  loading?: LoadingStrategy;\n\n  /**\n   * Viewport oracle strategies for 2D virtualized tables (e.g. MUI DataGrid, AG Grid,\n   * Braintrust-style grids where both rows and columns are virtualized simultaneously).\n   *\n   * When present, the cell-reading engine uses these to jump directly to the target\n   * row/column and to detect the 2D scroll hazard (scrolling to reveal a column can\n   * knock rows out of the vertical viewport, and vice versa).\n   *\n   * Completely optional and additive \u2014 existing `navigation` primitives remain the fallback.\n   */\n  viewport?: ViewportStrategy;\n}\n\n\nexport interface TableConfig<T = any> {\n  /** Selector for the table headers */\n  headerSelector?: string | ((root: Locator) => Locator);\n  /** Selector for the table rows */\n  rowSelector?: string;\n  /** Selector for the cells within a row */\n  cellSelector?: string | ((row: Locator) => Locator);\n  /** Number of pages to scan for verification */\n  maxPages?: number;\n  /**\n   * Default concurrency strategy for iteration methods.\n   * Can be overridden by the options passed to forEach, map, or filter.\n   */\n  concurrency?: RowIterationMode;\n  /** Hook to rename columns dynamically */\n  headerTransformer?: (args: { text: string, index: number, locator: Locator, seenHeaders: Set<string> }) => string | Promise<string>;\n  /** Automatically scroll to table on init */\n  autoScroll?: boolean;\n  /** Debug options for development and troubleshooting */\n  debug?: DebugConfig;\n  /** Reset hook */\n  onReset?: (context: TableContext) => Promise<void>;\n  /** All interaction strategies */\n  strategies?: TableStrategies;\n\n  /**\n   * Unified interface for reading and writing data to specific columns.\n   * Overrides both default extraction (toJSON) and filling (smartFill) logic.\n   */\n  columnOverrides?: Partial<Record<keyof T, ColumnOverride<T[keyof T]>>>;\n}\n\nexport interface FinalTableConfig<T = any> extends TableConfig<T> {\n  headerSelector: string | ((root: Locator) => Locator);\n  rowSelector: string;\n  cellSelector: string | ((row: Locator) => Locator);\n  maxPages: number;\n  autoScroll: boolean;\n  concurrency?: RowIterationMode;\n  debug?: TableConfig['debug'];\n  headerTransformer: (args: { text: string, index: number, locator: Locator, seenHeaders: Set<string> }) => string | Promise<string>;\n  onReset: (context: TableContext) => Promise<void>;\n  strategies: TableStrategies;\n}\n\n\nexport interface FillOptions {\n  /**\n   * Custom input mappers for specific columns.\n   * Maps column names to functions that return the input locator for that cell.\n   */\n  inputMappers?: Record<string, (cell: Locator) => Locator>;\n}\n\n\n\n/** Callback context passed to forEach, map, and filter. */\nexport type RowIterationContext<T = any> = {\n  row: SmartRow<T>;\n  /** 0-based iteration counter \u2014 the order this row was visited, not its DOM position or grid identity. @deprecated Use `index` instead. `rowIndex` will be removed in v7.0.0. */\n  rowIndex: number;\n  /** 0-based iteration counter \u2014 the order this row was visited, not its DOM position or grid identity. */\n  index: number;\n  /** 0-based page index \u2014 which page this row was collected from. */\n  pageIndex: number;\n  stop: () => void;\n};\n\n/** Concurrency modes for row iteration. */\nexport type RowIterationMode = 'parallel' | 'sequential' | 'synchronized';\n\n/** Shared options for forEach, map, and filter. */\nexport type RowIterationOptions = {\n  /** Maximum number of pages to iterate. Defaults to config.maxPages. */\n  maxPages?: number;\n  /**\n   * Concurrency strategy for iteration.\n   * - 'parallel': Full parallel execution of both navigation and actions.\n   * - 'synchronized': Parallel navigation (lock-step) with serial actions.\n   * - 'sequential': Strictly serial one-at-a-time execution. No parallel navigation.\n   * @default 'parallel' (for map), 'sequential' (for forEach/filter)\n   */\n  concurrency?: RowIterationMode;\n  /**\n   * Deduplication strategy. Use when rows may repeat across iterations\n   * (e.g. infinite scroll tables). Returns a unique key per row.\n   */\n  dedupe?: DedupeStrategy;\n  /**\n   * When true, use goNextBulk (if present) to advance pages during iteration.\n   * @default false \u2014 uses goNext for one-page-at-a-time advancement\n   */\n  useBulkPagination?: boolean;\n};\n\nexport interface TableResult<T = any> extends AsyncIterable<{ row: SmartRow<T>; rowIndex: number; index: number; pageIndex: number }> {\n  /**\n   * Represents the current page index of the table's DOM.\n   * Starts at 0. Automatically maintained by the library during pagination and bringIntoView.\n   */\n  currentPageIndex: number;\n\n  /**\n   * Initializes the table by resolving headers. Must be called before using sync methods.\n   * @param options Optional timeout for header resolution (default: 3000ms)\n   */\n  init(options?: { timeout?: number }): Promise<TableResult<T>>;\n\n  /**\n   * SYNC: Checks if the table has been initialized.\n   * @returns true if init() has been called and completed, false otherwise\n   */\n  isInitialized(): boolean;\n\n  getHeaders: () => Promise<string[]>;\n  getHeaderCell: (columnName: string) => Promise<Locator>;\n\n  /**\n   * Finds a row by filters on the current page only. Returns immediately (sync).\n   * Throws error if table is not initialized.\n   * @note The returned SmartRow may have `rowIndex` as 0 when the match is not the first row.\n   * Use getRowByIndex(index) when you need a known index (e.g. for bringIntoView()).\n   */\n  getRow: (\n    filters: Record<string, FilterValue>,\n    options?: { exact?: boolean }\n  ) => SmartRow<T>;\n\n  /**\n   * Gets a row by 0-based index on the current page.\n   * Throws error if table is not initialized.\n   * @param index 0-based row index\n   */\n  getRowByIndex: (\n    index: number\n  ) => SmartRow<T>;\n\n  /**\n   * ASYNC: Searches for a single row across pages using pagination.\n   * Auto-initializes the table if not already initialized.\n   * @param filters - The filter criteria to match\n   * @param options - Search options including exact match and max pages\n   */\n  findRow: (\n    filters: Record<string, FilterValue>,\n    options?: { exact?: boolean, maxPages?: number }\n  ) => Promise<SmartRow<T>>;\n\n  /**\n   * ASYNC: Searches for all matching rows across pages using pagination.\n   * Auto-initializes the table if not already initialized.\n   * @param filters - The filter criteria to match (omit or pass {} for all rows)\n   * @param options - Search options including exact match and max pages\n   */\n  findRows: (\n    filters?: Record<string, FilterValue>,\n    options?: { exact?: boolean, maxPages?: number, useBulkPagination?: boolean }\n  ) => Promise<SmartRowArray<T>>;\n\n  /**\n   * Navigates to a specific column using the configured CellNavigationStrategy.\n   */\n  scrollToColumn: (columnName: string) => Promise<void>;\n\n  /**\n   * Counts the number of rows currently on the page.\n   * Does not paginate.\n   */\n  countRows: () => Promise<number>;\n\n  /**\n   * Iterates over rows and extracts the value of a single column.\n   * More efficient than map + toJSON for single-column extraction.\n   * @param columnName - The name of the column to extract\n   * @param options - Iteration options\n   */\n  mapColumn<R = string>(columnName: string, options?: RowIterationOptions): Promise<R[]>;\n\n  /**\n   * Iterates over rows and extracts the value of a single column as strings.\n   * @param columnName - The name of the column to extract\n   * @param options - Iteration options\n   */\n  getColumnValues(columnName: string, options?: RowIterationOptions): Promise<string[]>;\n\n\n  /**\n   * Resets the table state (clears cache, flags) and invokes the onReset strategy.\n   */\n  reset: () => Promise<void>;\n\n  /**\n   * Revalidates the table's structure (headers, columns) without resetting pagination or state.\n   * Useful when columns change visibility or order dynamically.\n   */\n  revalidate: () => Promise<void>;\n\n  /**\n   * Iterates every row across all pages, calling the callback for side effects.\n   * Execution is sequential by default (safe for interactions like clicking/filling).\n   * Call `stop()` in the callback to end iteration early.\n   *\n   * @param callback - Function receiving { row, rowIndex, stop }\n   * @param options - maxPages, concurrency, dedupe, useBulkPagination\n   *\n   * @example\n   * await table.forEach(async ({ row, stop }) => {\n   *   if (await row.getCell('Status').innerText() === 'Done') stop();\n   *   await row.getCell('Checkbox').click();\n   * });\n   */\n  forEach(\n    callback: (ctx: RowIterationContext<T>) => void | Promise<void>,\n    options?: RowIterationOptions\n  ): Promise<void>;\n\n  /**\n   * Transforms every row across all pages into a value. Returns a flat array.\n   * Execution is parallel within each page by default (safe for reads).\n   * Call `stop()` to halt after the current page finishes.\n   *\n   * > **\u26A0\uFE0F UI Interactions:** `map` defaults to `concurrency: 'parallel'`. If your callback opens popovers,\n   * > fills inputs, or otherwise mutates UI state, pass `concurrency: 'sequential'` (or `'synchronized'`\n   * > when navigation must stay lock-step) to avoid overlapping interactions.\n   *\n   * @param callback - Function receiving { row, rowIndex, stop }\n   * @param options - maxPages, concurrency, dedupe, useBulkPagination\n   *\n   * @example\n   * // Data extraction \u2014 parallel is safe\n   * const emails = await table.map(({ row }) => row.getCell('Email').innerText());\n   *\n   * @example\n   * // UI interactions \u2014 use sequential (or synchronized) concurrency\n   * const assignees = await table.map(async ({ row }) => {\n   *   await row.getCell('Assignee').locator('button').click();\n   *   const name = await page.locator('.popover .name').innerText();\n   *   await page.keyboard.press('Escape');\n   *   return name;\n   * }, { concurrency: 'sequential' });\n   */\n  map<R>(\n    callback: (ctx: RowIterationContext<T>) => R | Promise<R>,\n    options?: RowIterationOptions\n  ): Promise<R[]>;\n\n  /**\n   * Filters rows across all pages by an async predicate. Returns a SmartRowArray.\n   * Rows are returned as-is \u2014 call `bringIntoView()` on each if needed.\n   * Execution is sequential by default.\n   *\n   * @param predicate - Function receiving { row, rowIndex, stop }\n   * @param options - maxPages, concurrency, dedupe, useBulkPagination\n   *\n   * @example\n   * const active = await table.filter(async ({ row }) =>\n   *   await row.getCell('Status').innerText() === 'Active'\n   * );\n   */\n  filter(\n    predicate: (ctx: RowIterationContext<T>) => boolean | Promise<boolean>,\n    options?: RowIterationOptions\n  ): Promise<SmartRowArray<T>>;\n\n  /**\n   * Provides access to sorting actions and assertions.\n   */\n  sorting: {\n    /**\n     * Applies the configured sorting strategy to the specified column.\n     * @param columnName The name of the column to sort.\n     * @param direction The direction to sort ('asc' or 'desc').\n     */\n    apply(columnName: string, direction: 'asc' | 'desc'): Promise<void>;\n    /**\n     * Gets the current sort state of a column using the configured sorting strategy.\n     * @param columnName The name of the column to check.\n     * @returns A promise that resolves to 'asc', 'desc', or 'none'.\n     */\n    getState(columnName: string): Promise<'asc' | 'desc' | 'none'>;\n  };\n\n  /**\n   * Generate an AI-friendly configuration prompt for debugging.\n   * Outputs table HTML and TypeScript definitions to help AI assistants generate config.\n   * Automatically throws an Error containing the prompt.\n   */\n  generateConfig: () => Promise<void>;\n\n  /**\n   * @deprecated Use `generateConfig()` instead. Will be removed in v7.0.0.\n   */\n  generateConfigPrompt: () => Promise<void>;\n}\n";

package/dist/typeContext.js

@@ -506,9 +506,14 @@ export interface LoadingStrategy {
    * - 'skip': use empty string for this cell value
    * - 'read-as-is': read the cell content even though it's still loading (default)
    * - 'throw': throw an error with column name, row index and timeout info
+   * - callback: called with (cell, columnName, row); its return value becomes the cell's string value
    * Defaults to 'read-as-is' when cellLoadingTimeout is set.
    */
-  onCellLoadingTimeout?: 'skip' | 'read-as-is' | 'throw';
+  onCellLoadingTimeout?:
+    | 'skip'
+    | 'read-as-is'
+    | 'throw'
+    | ((cell: import('@playwright/test').Locator, columnName: string, row: SmartRow) => Promise<string>);
 }
 
 /**

package/dist/types.d.ts

@@ -459,9 +459,10 @@ export interface LoadingStrategy {
      * - 'skip': use empty string for this cell value
      * - 'read-as-is': read the cell content even though it's still loading (default)
      * - 'throw': throw an error with column name, row index and timeout info
+     * - callback: called with (cell, columnName, row); its return value becomes the cell's string value
      * Defaults to 'read-as-is' when cellLoadingTimeout is set.
      */
-    onCellLoadingTimeout?: 'skip' | 'read-as-is' | 'throw';
+    onCellLoadingTimeout?: 'skip' | 'read-as-is' | 'throw' | ((cell: import('@playwright/test').Locator, columnName: string, row: SmartRow) => Promise<string>);
 }
 /**
  * Organized container for all table interaction strategies.

package/dist/useTable.js

@@ -100,8 +100,6 @@ const useTable = (rootLocator, configOptions = {}) => {
             return item(parent);
         return item;
     };
-    // Internal State
-    let _hasPaginated = false;
     // Helpers
     const log = (msg) => {
         (0, debugUtils_1.logDebug)(config, 'verbose', msg);
@@ -135,7 +133,7 @@ const useTable = (rootLocator, configOptions = {}) => {
         return (0, smartRow_1.default)(rowLocator, map, rowIndex, config, rootLocator, resolve, finalTable, tablePageIndex, barrier);
     };
     const tableState = { currentPageIndex: 0 };
-    const rowFinder = new rowFinder_1.RowFinder(rootLocator, config, resolve, filterEngine, tableMapper, _makeSmart, tableState);
+    const rowFinder = new rowFinder_1.RowFinder(rootLocator, config, resolve, filterEngine, tableMapper, _makeSmart, tableState, (useBulk) => _advancePage(useBulk));
     /** Builds a full TableContext/StrategyContext with getHeaderCell, getHeaders, scrollToColumn. Set after result is created. */
     let createStrategyContext = () => ({ root: rootLocator, config, page: rootLocator.page(), resolve });
     const _getCleanHtml = async (loc) => {
@@ -326,7 +324,6 @@ const useTable = (rootLocator, configOptions = {}) => {
             else if (hasPaginationInConfig) {
                 log("No goToFirst strategy configured. Table may not be on page 1.");
             }
-            _hasPaginated = false;
             tableState.currentPageIndex = 0;
             tableMapper.clear();
             log("Table reset complete. Calling autoInit to restore state.");
@@ -490,7 +487,11 @@ const useTable = (rootLocator, configOptions = {}) => {
             log("Generating table config prompt...");
             const html = await _getCleanHtml(rootLocator);
             const separator = "=".repeat(50);
-            const content = `\n${separator} \n🤖 COPY INTO GEMINI / ChatGPT 🤖\n${separator} \nI am using 'playwright-smart-table'.\nTarget Table Locator: ${rootLocator.toString()} \nGenerate config for: \n\`\`\`html\n${html.substring(0, 10000)} ...\n\`\`\`\n${separator}\n`;
+            const maxLen = 10000;
+            const truncated = html.length > maxLen;
+            const htmlSnippet = truncated ? html.substring(0, maxLen) : html;
+            const truncationNote = truncated ? `\n[truncated — ${html.length} chars total, showing first ${maxLen}]` : '';
+            const content = `\n${separator} \n🤖 Paste into your AI assistant 🤖\n${separator} \nI am using 'playwright-smart-table'.\nTarget Table Locator: ${rootLocator.toString()} \nGenerate config for: \n\`\`\`html\n${htmlSnippet}${truncationNote}\n\`\`\`\n${separator}\n`;
             await _handlePrompt('Smart Table Config', content);
         },
         generateConfigPrompt: async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.14.0",
+  "version": "6.16.0",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",
@@ -64,6 +64,23 @@
     "./presets/mui": {
       "types": "./dist/presets/mui.d.ts",
       "default": "./dist/presets/mui.js"
+    },
+    "./presets/rdg": {
+      "types": "./dist/presets/rdg.d.ts",
+      "default": "./dist/presets/rdg.js"
+    },
+    "./presets/glide": {
+      "types": "./dist/presets/glide/index.d.ts",
+      "default": "./dist/presets/glide/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "types": ["./dist/types.d.ts"],
+      "presets": ["./dist/presets/index.d.ts"],
+      "presets/mui": ["./dist/presets/mui.d.ts"],
+      "presets/rdg": ["./dist/presets/rdg.d.ts"],
+      "presets/glide": ["./dist/presets/glide/index.d.ts"]
     }
   },
   "keywords": [
@@ -90,14 +107,19 @@
     "@stryker-mutator/core": "^9.6.0",
     "@stryker-mutator/vitest-runner": "^9.6.0",
     "@types/node": "^25.5.2",
-    "@vitest/coverage-v8": "^3.2.4",
-    "@vitest/ui": "^3.2.4",
-    "happy-dom": "^20.8.3",
+    "@vitest/coverage-v8": "^3.2.6",
+    "@vitest/ui": "^3.2.6",
+    "happy-dom": "^20.10.6",
     "husky": "^9.1.7",
     "typescript": "^6.0.2",
     "vitepress": "^1.6.4",
     "vitepress-plugin-tabs": "^0.9.0",
-    "vitest": "^3.2.4"
+    "vitest": "^3.2.6"
   },
-  "packageManager": "pnpm@10.33.2"
+  "packageManager": "pnpm@10.33.2",
+  "pnpm": {
+    "overrides": {
+      "fast-uri": ">=3.1.2"
+    }
+  }
 }