@rickcedwhat/playwright-smart-table 6.19.0 → 6.20.1-next.230dedf

package/dist/engine/rowFinder.d.ts

@@ -13,9 +13,13 @@ export declare class RowFinder<T = any> {
     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, barrier?: NavigationBarrier) => 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, rowSelector?: string) => SmartRow<T>, tableState?: {
         currentPageIndex: number;
     }, advancePage?: (useBulk: boolean) => Promise<boolean>);
+    private splitFilters;
+    static matchReadValue(readValue: string, filterValue: FilterValue, exact: boolean): boolean;
+    matchesOverrideFilters(rowLocator: Locator, overrideFilters: Record<string, FilterValue>, map: Map<string, number>, exact: boolean): Promise<boolean>;
+    matchesSyntheticFilters(rowLocator: Locator, syntheticFilters: Record<string, FilterValue>, map: Map<string, number>, exact: boolean): Promise<boolean>;
     findRow(filters: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
@@ -36,5 +40,6 @@ export declare class RowFinder<T = any> {
      * same selector/scope as everywhere else, so a string, function, or Locator rowSelector
      * all behave identically. (#350)
      */
+    private throwIfAmbiguous;
     private scanDomPosition;
 }

package/dist/engine/rowFinder.js

@@ -18,6 +18,73 @@ class RowFinder {
         this.advancePage = advancePage;
         this.resolve = resolve;
     }
+    splitFilters(filters) {
+        var _a, _b, _c;
+        const domFilters = {};
+        const overrideFilters = {};
+        const syntheticFilters = {};
+        for (const [key, value] of Object.entries(filters)) {
+            if ((_a = this.config.syntheticColumns) === null || _a === void 0 ? void 0 : _a[key]) {
+                syntheticFilters[key] = value;
+            }
+            else if ((_c = (_b = this.config.columnOverrides) === null || _b === void 0 ? void 0 : _b[key]) === null || _c === void 0 ? void 0 : _c.read) {
+                overrideFilters[key] = value;
+            }
+            else {
+                domFilters[key] = value;
+            }
+        }
+        return { domFilters, overrideFilters, syntheticFilters };
+    }
+    static matchReadValue(readValue, filterValue, exact) {
+        if (typeof filterValue === 'function') {
+            throw new Error(`[SmartTable] Function filters are not supported for columns with columnOverrides.read. ` +
+                `Use a string, number, or RegExp filter instead.`);
+        }
+        if (typeof filterValue === 'string' || typeof filterValue === 'number') {
+            const target = String(filterValue);
+            return exact ? readValue === target : readValue.includes(target);
+        }
+        if (filterValue instanceof RegExp) {
+            return filterValue.test(readValue);
+        }
+        return true;
+    }
+    async matchesOverrideFilters(rowLocator, overrideFilters, map, exact) {
+        for (const [colName, filterValue] of Object.entries(overrideFilters)) {
+            const colIndex = map.get(colName);
+            if (colIndex === undefined)
+                continue;
+            const override = this.config.columnOverrides[colName];
+            const cell = this.resolve(this.config.cellSelector, rowLocator).nth(colIndex);
+            const getCell = (name) => {
+                const idx = map.get(name);
+                if (idx === undefined)
+                    throw new Error(`Column "${name}" not found`);
+                return this.resolve(this.config.cellSelector, rowLocator).nth(idx);
+            };
+            const context = {
+                row: this.makeSmartRow(rowLocator, map, undefined),
+                columnName: colName,
+                columnIndex: colIndex,
+                getCell,
+            };
+            const readValue = String(await override.read(cell, context));
+            if (!RowFinder.matchReadValue(readValue, filterValue, exact))
+                return false;
+        }
+        return true;
+    }
+    async matchesSyntheticFilters(rowLocator, syntheticFilters, map, exact) {
+        const smartRow = this.makeSmartRow(rowLocator, map, undefined);
+        for (const [colName, filterValue] of Object.entries(syntheticFilters)) {
+            const def = this.config.syntheticColumns[colName];
+            const computedValue = String(await def.compute(smartRow));
+            if (!RowFinder.matchReadValue(computedValue, filterValue, exact))
+                return false;
+        }
+        return true;
+    }
     async findRow(filters, options = {}) {
         (0, debugUtils_1.logDebug)(this.config, 'info', 'Searching for row', filters);
         await this.tableMapper.getMap();
@@ -26,8 +93,8 @@ class RowFinder {
             (0, debugUtils_1.logDebug)(this.config, 'info', 'Row found');
             await (0, debugUtils_1.debugDelay)(this.config, 'findRow');
             const map = await this.tableMapper.getMap();
-            const rowIndex = await this.resolveRowIndex(rowLocator);
-            return this.makeSmartRow(rowLocator, map, rowIndex, this.tableState.currentPageIndex);
+            const resolved = await this.resolveRowIndex(rowLocator);
+            return this.makeSmartRow(rowLocator, map, resolved === null || resolved === void 0 ? void 0 : resolved.index, this.tableState.currentPageIndex, undefined, resolved === null || resolved === void 0 ? void 0 : resolved.selector);
         }
         (0, debugUtils_1.logDebug)(this.config, 'error', 'Row not found', filters);
         await (0, debugUtils_1.debugDelay)(this.config, 'findRow');
@@ -47,12 +114,14 @@ class RowFinder {
         (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: starting (maxPages=${effectiveMaxPages}, filters=${JSON.stringify(filtersRecord)})`);
         const tracker = new elementTracker_1.ElementTracker('findRows');
         try {
+            const { domFilters, overrideFilters, syntheticFilters } = this.splitFilters(filtersRecord);
+            const hasOverrideFilters = Object.keys(overrideFilters).length > 0;
+            const hasSyntheticFilters = Object.keys(syntheticFilters).length > 0;
             const collectMatches = async () => {
-                var _a, _b;
+                var _a, _b, _c, _d;
                 let rowLocators = this.resolve(this.config.rowSelector, this.rootLocator);
-                // Only apply filters if we have them
-                if (Object.keys(filtersRecord).length > 0) {
-                    rowLocators = this.filterEngine.applyFilters(rowLocators, filtersRecord, map, (_a = options === null || options === void 0 ? void 0 : options.exact) !== null && _a !== void 0 ? _a : false, this.rootLocator.page(), this.rootLocator);
+                if (Object.keys(domFilters).length > 0) {
+                    rowLocators = this.filterEngine.applyFilters(rowLocators, domFilters, map, (_a = options === null || options === void 0 ? void 0 : options.exact) !== null && _a !== void 0 ? _a : false, this.rootLocator.page(), this.rootLocator);
                 }
                 // Get only newly seen matched rows
                 const newIndices = await tracker.getUnseenIndices(rowLocators);
@@ -62,8 +131,8 @@ class RowFinder {
                 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 rowIndex = await (0, rowResolution_1.resolveLogicalRowIndex)(currentRows[idx], this.config, () => allRows.length);
-                    const smartRow = this.makeSmartRow(currentRows[idx], map, rowIndex, this.tableState.currentPageIndex, barrier);
+                    const resolved = await (0, rowResolution_1.resolveLogicalRowIndex)(currentRows[idx], this.config, () => allRows.length);
+                    const smartRow = this.makeSmartRow(currentRows[idx], map, resolved === null || resolved === void 0 ? void 0 : resolved.index, this.tableState.currentPageIndex, barrier, resolved === null || resolved === void 0 ? void 0 : resolved.selector);
                     // findRows skips a still-loading row when no timeout is configured (legacy
                     // behavior) — see resolveRowLoading's `noTimeoutAction: 'skip'`.
                     const loadingOutcome = await (0, rowResolution_1.resolveRowLoading)(smartRow, this.config.strategies.loading, 'skip', (msg) => (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: ${msg}`));
@@ -74,6 +143,14 @@ class RowFinder {
                         }
                         continue; // 'skip'
                     }
+                    if (hasOverrideFilters && !await this.matchesOverrideFilters(currentRows[idx], overrideFilters, map, (_c = options === null || options === void 0 ? void 0 : options.exact) !== null && _c !== void 0 ? _c : false)) {
+                        barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
+                        continue;
+                    }
+                    if (hasSyntheticFilters && !await this.matchesSyntheticFilters(currentRows[idx], syntheticFilters, map, (_d = options === null || options === void 0 ? void 0 : options.exact) !== null && _d !== void 0 ? _d : false)) {
+                        barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
+                        continue;
+                    }
                     allRows.push(smartRow);
                     added++;
                 }
@@ -91,7 +168,8 @@ class RowFinder {
                 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`);
+                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: pagination returned false — final scan`);
+                    await collectMatches();
                     break;
                 }
                 const pagesJumped = this.tableState.currentPageIndex - prevPage;
@@ -129,26 +207,37 @@ class RowFinder {
                 }
             }
             const allRows = this.resolve(this.config.rowSelector, this.rootLocator);
-            const matchedRows = this.filterEngine.applyFilters(allRows, filters, map, options.exact || false, this.rootLocator.page(), this.rootLocator);
-            const count = await matchedRows.count();
-            (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: Found ${count} matches.`);
-            if (count > 1) {
-                const sampleData = [];
-                try {
-                    const firstFewRows = await matchedRows.all();
-                    const sampleCount = Math.min(firstFewRows.length, 3);
-                    for (let i = 0; i < sampleCount; i++) {
-                        const rowData = await this.makeSmartRow(firstFewRows[i], map, 0, this.tableState.currentPageIndex).toJSON();
-                        sampleData.push(JSON.stringify(rowData));
-                    }
-                }
-                catch (e) { }
-                const sampleMsg = sampleData.length > 0 ? `\nSample matching rows:\n${sampleData.map((d, i) => `  ${i + 1}. ${d}`).join('\n')}` : '';
-                throw new Error(`Ambiguous Row: Found ${count} rows matching ${JSON.stringify(filters)} on page ${this.tableState.currentPageIndex}. ` +
-                    `Expected exactly one match. Try adding more filters to make your query unique.${sampleMsg}`);
+            const { domFilters, overrideFilters, syntheticFilters } = this.splitFilters(filters);
+            const hasPostFilters = Object.keys(overrideFilters).length > 0 || Object.keys(syntheticFilters).length > 0;
+            let matchedRows = allRows;
+            if (Object.keys(domFilters).length > 0) {
+                matchedRows = this.filterEngine.applyFilters(allRows, domFilters, map, options.exact || false, this.rootLocator.page(), this.rootLocator);
+            }
+            if (!hasPostFilters) {
+                const count = await matchedRows.count();
+                (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: Found ${count} matches.`);
+                if (count > 1)
+                    await this.throwIfAmbiguous(await matchedRows.all(), filters, map);
+                if (count === 1)
+                    return matchedRows.first();
+            }
+            else {
+                const candidates = await matchedRows.all();
+                (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: ${candidates.length} DOM candidate(s), post-filtering with override/synthetic columns`);
+                const results = await Promise.all(candidates.map(async (c) => {
+                    if (Object.keys(overrideFilters).length > 0 && !await this.matchesOverrideFilters(c, overrideFilters, map, options.exact || false))
+                        return false;
+                    if (Object.keys(syntheticFilters).length > 0 && !await this.matchesSyntheticFilters(c, syntheticFilters, map, options.exact || false))
+                        return false;
+                    return true;
+                }));
+                const postFilterMatches = candidates.filter((_, i) => results[i]);
+                (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: ${postFilterMatches.length} match(es) after post-filter`);
+                if (postFilterMatches.length > 1)
+                    await this.throwIfAmbiguous(postFilterMatches, filters, map);
+                if (postFilterMatches.length === 1)
+                    return postFilterMatches[0];
             }
-            if (count === 1)
-                return matchedRows.first();
             if (pagesScanned < effectiveMaxPages) {
                 (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: Not found. Attempting pagination...`);
                 // Default to single-step goNext; bulk is opt-in via useBulkPagination: true (#349).
@@ -164,7 +253,9 @@ class RowFinder {
                     continue;
                 }
                 else {
-                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: Pagination failed (end of data).`);
+                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: pagination returned false — final scan`);
+                    pagesScanned = effectiveMaxPages;
+                    continue;
                 }
             }
             return null;
@@ -183,6 +274,20 @@ class RowFinder {
      * same selector/scope as everywhere else, so a string, function, or Locator rowSelector
      * all behave identically. (#350)
      */
+    async throwIfAmbiguous(rows, filters, map) {
+        const sampleData = [];
+        try {
+            const sampleCount = Math.min(rows.length, 3);
+            for (let i = 0; i < sampleCount; i++) {
+                const rowData = await this.makeSmartRow(rows[i], map, 0, this.tableState.currentPageIndex).toJSON();
+                sampleData.push(JSON.stringify(rowData));
+            }
+        }
+        catch (e) { }
+        const sampleMsg = sampleData.length > 0 ? `\nSample matching rows:\n${sampleData.map((d, i) => `  ${i + 1}. ${d}`).join('\n')}` : '';
+        throw new Error(`Ambiguous Row: Found ${rows.length} rows matching ${JSON.stringify(filters)} on page ${this.tableState.currentPageIndex}. ` +
+            `Expected exactly one match. Try adding more filters to make your query unique.${sampleMsg}`);
+    }
     async scanDomPosition(rowLocator) {
         const targetHandle = await rowLocator.elementHandle();
         if (!targetHandle)

package/dist/engine/rowResolution.d.ts

@@ -1,5 +1,12 @@
 import type { Locator } from '@playwright/test';
-import type { FinalTableConfig, LoadingStrategy, SmartRow } from '../types';
+import type { FinalTableConfig, LoadingStrategy, RowIndexResult, SmartRow } from '../types';
+/** Normalized result from resolveRowIndex — always has `.index`, optionally `.selector`. */
+export interface ResolvedRowIndex {
+    index: number;
+    selector?: string;
+}
+/** Extract the numeric index from a {@link RowIndexResult}. */
+export declare function normalizeRowIndexResult(result: RowIndexResult): ResolvedRowIndex;
 /**
  * Single source of truth for "what is this row's logical index?" (#362 consolidation).
  *
@@ -7,10 +14,10 @@ import type { FinalTableConfig, LoadingStrategy, SmartRow } from '../types';
  * otherwise, and when the strategy returns `undefined`, defers to the caller-provided
  * `fallback` — a running counter for iteration/`findRows`, or a DOM-position scan for `findRow`.
  *
- * This replaces the three inline variants that previously answered the index question
- * (findRow's private method, findRows' inline expression, and — later — map's counter).
+ * Returns a {@link ResolvedRowIndex} with the numeric index and, when the strategy provides
+ * one, a CSS selector for building a self-healing row locator.
  */
-export declare function resolveLogicalRowIndex(row: Locator, config: Pick<FinalTableConfig, 'strategies'>, fallback: () => number | undefined | Promise<number | undefined>): Promise<number | undefined>;
+export declare function resolveLogicalRowIndex(row: Locator, config: Pick<FinalTableConfig, 'strategies'>, fallback: () => number | undefined | Promise<number | undefined>): Promise<ResolvedRowIndex | undefined>;
 /** What the caller should do with a row after checking its loading state. */
 export type RowLoadingOutcome = 'process' | 'skip' | 'throw';
 /**

package/dist/engine/rowResolution.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRowIndexResult = normalizeRowIndexResult;
 exports.resolveLogicalRowIndex = resolveLogicalRowIndex;
 exports.resolveRowLoading = resolveRowLoading;
+/** Extract the numeric index from a {@link RowIndexResult}. */
+function normalizeRowIndexResult(result) {
+    return typeof result === 'number' ? { index: result } : result;
+}
 /**
  * Single source of truth for "what is this row's logical index?" (#362 consolidation).
  *
@@ -9,18 +14,18 @@ exports.resolveRowLoading = resolveRowLoading;
  * otherwise, and when the strategy returns `undefined`, defers to the caller-provided
  * `fallback` — a running counter for iteration/`findRows`, or a DOM-position scan for `findRow`.
  *
- * This replaces the three inline variants that previously answered the index question
- * (findRow's private method, findRows' inline expression, and — later — map's counter).
+ * Returns a {@link ResolvedRowIndex} with the numeric index and, when the strategy provides
+ * one, a CSS selector for building a self-healing row locator.
  */
 async function resolveLogicalRowIndex(row, config, fallback) {
     const strategy = config.strategies.resolveRowIndex;
     if (strategy) {
         const resolved = await strategy(row);
         if (resolved !== undefined)
-            return resolved;
-        // Strategy returned undefined — fall through to the caller's fallback.
+            return normalizeRowIndexResult(resolved);
     }
-    return fallback();
+    const fb = await fallback();
+    return fb !== undefined ? { index: fb } : undefined;
 }
 /**
  * Single source of truth for the per-row loading wait (#362 consolidation).

package/dist/engine/tableIteration.d.ts

@@ -7,7 +7,7 @@ export interface TableIterationEnv<T = any> {
     getRowLocators: () => Locator;
     getMap: () => Map<string, number>;
     advancePage: (useBulk: boolean) => Promise<boolean>;
-    makeSmartRow: (rowLocator: Locator, map: Map<string, number>, rowIndex: number, tablePageIndex?: number, barrier?: NavigationBarrier) => SmartRow<T>;
+    makeSmartRow: (rowLocator: Locator, map: Map<string, number>, rowIndex: number, tablePageIndex?: number, barrier?: NavigationBarrier, rowSelector?: string) => SmartRow<T>;
     createSmartRowArray: (rows: SmartRow<T>[]) => SmartRowArray<T>;
     config: FinalTableConfig<T>;
     getPage: () => Page;

package/dist/engine/tableIteration.js

@@ -42,6 +42,7 @@ async function runMap(env, callback, options = {}, label = 'map') {
         let stopped = false;
         let stoppedIndex = Infinity;
         let pagesScanned = 1;
+        let reachedEnd = false;
         const stop = (idx) => {
             if (!stopped) {
                 log(env.config, `${label}: stop() called at row ${idx} — halting`);
@@ -58,11 +59,16 @@ async function runMap(env, callback, options = {}, label = 'map') {
             // they're picked up on a later page once scrolled into view — preventing overscan from
             // being ingested (#353) or double-collected via node recycling (#357). No-op when no
             // viewport reports visible rows.
+            //
+            // #384: overscan rows ABOVE the visible range have already scrolled past and will never
+            // re-enter the viewport — collect them now. Only defer rows BELOW the visible range
+            // (they'll scroll into view on a later page).
             let candidateIndices = allIndices;
             const getVisibleRowIndices = (_f = env.config.strategies.viewport) === null || _f === void 0 ? void 0 : _f.getVisibleRowIndices;
             if (getVisibleRowIndices) {
                 const visible = new Set(await getVisibleRowIndices(env.getContext()));
-                candidateIndices = allIndices.filter(idx => visible.has(idx));
+                const minVisible = visible.size > 0 ? Math.min(...visible) : Infinity;
+                candidateIndices = allIndices.filter(idx => visible.has(idx) || idx < minVisible);
                 if (candidateIndices.length !== allIndices.length) {
                     log(env.config, `${label}: viewport visible filter — ${candidateIndices.length}/${allIndices.length} row(s) in view`);
                 }
@@ -90,8 +96,9 @@ async function runMap(env, callback, options = {}, label = 'map') {
                 // correct on virtualized tables); otherwise it equals the enumeration counter.
                 const smartRows = await Promise.all(newIndices.map(async (idx, i) => {
                     var _a;
-                    const logicalIndex = (_a = await (0, rowResolution_1.resolveLogicalRowIndex)(pageRows[idx], env.config, () => positionBase + i)) !== null && _a !== void 0 ? _a : (positionBase + i);
-                    const sr = env.makeSmartRow(pageRows[idx], map, logicalIndex, env.getCurrentPageIndex(), barrier);
+                    const resolved = await (0, rowResolution_1.resolveLogicalRowIndex)(pageRows[idx], env.config, () => positionBase + i);
+                    const logicalIndex = (_a = resolved === null || resolved === void 0 ? void 0 : resolved.index) !== null && _a !== void 0 ? _a : (positionBase + i);
+                    const sr = env.makeSmartRow(pageRows[idx], map, logicalIndex, env.getCurrentPageIndex(), barrier, resolved === null || resolved === void 0 ? void 0 : resolved.selector);
                     // Mark as part of an iteration batch so toJSON's #366 re-pin uses rescan-only recovery
                     // (no scroll-back) — scrolling here would disrupt sibling rows' positional locators.
                     sr._inBatch = true;
@@ -113,13 +120,13 @@ async function runMap(env, callback, options = {}, label = 'map') {
                         if (loadingOutcome === 'throw') {
                             throw new Error(`[SmartTable] Row ${row.rowIndex} did not finish loading within ${(_a = env.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.rowLoadingTimeout}ms`);
                         }
+                        let dedupeKey;
                         if (dedupeKeys && dedupeStrategy) {
-                            const key = await dedupeStrategy(row);
-                            if (dedupeKeys.has(key)) {
-                                log(env.config, `${label}: dedupe skip key="${key}"`);
+                            dedupeKey = await dedupeStrategy(row);
+                            if (dedupeKeys.has(dedupeKey)) {
+                                log(env.config, `${label}: dedupe skip key="${dedupeKey}"`);
                                 return SKIP;
                             }
-                            dedupeKeys.add(key);
                         }
                         // Execute callback (optionally serialized via mutex)
                         const runCallback = async () => {
@@ -128,12 +135,13 @@ async function runMap(env, callback, options = {}, label = 'map') {
                             log(env.config, `${label}: processing row (index ${enumIndex}, rowIndex ${row.rowIndex})`);
                             return await callback({ row, index: enumIndex, rowIndex: row.rowIndex, pageIndex: env.getCurrentPageIndex(), stop: () => stop(enumIndex) });
                         };
-                        if (actionMutex) {
-                            return await actionMutex.run(runCallback);
-                        }
-                        else {
-                            return await runCallback();
+                        const result = actionMutex
+                            ? await actionMutex.run(runCallback)
+                            : await runCallback();
+                        if (dedupeKeys && dedupeKey !== undefined && result !== SKIP) {
+                            dedupeKeys.add(dedupeKey);
                         }
+                        return result;
                     }
                     finally {
                         // Ensure the barrier is notified once per row, even on error or skip.
@@ -159,12 +167,13 @@ async function runMap(env, callback, options = {}, label = 'map') {
                 }
                 rowIndex += batchSize;
             }
-            if (stopped || pagesScanned >= effectiveMaxPages)
+            if (stopped || pagesScanned >= effectiveMaxPages || reachedEnd)
                 break;
             log(env.config, `${label}: advancing to next page (${pagesScanned} → ${pagesScanned + 1})`);
             if (!await env.advancePage(useBulk)) {
-                log(env.config, `${label}: no more pages — done`);
-                break;
+                log(env.config, `${label}: pagination returned false — final scan`);
+                reachedEnd = true;
+                continue;
             }
             pagesScanned++;
         }

package/dist/engine/tableMapper.js

@@ -14,7 +14,7 @@ class TableMapper {
         (0, debugUtils_1.logDebug)(this.config, 'verbose', msg);
     }
     async getMap(timeout) {
-        var _a;
+        var _a, _b;
         if (this._headerMap)
             return this._headerMap;
         this.log('Mapping headers...');
@@ -56,8 +56,15 @@ class TableMapper {
             try {
                 const rawHeaders = await strategy(context);
                 const entries = await this.processHeaders(rawHeaders);
-                // Success
-                this._headerMap = new Map(entries);
+                // Success — validate before caching so a collision doesn't leave stale state
+                const headerMap = new Map(entries);
+                const syntheticNames = Object.keys((_b = this.config.syntheticColumns) !== null && _b !== void 0 ? _b : {});
+                const collisions = syntheticNames.filter(name => headerMap.has(name));
+                if (collisions.length > 0) {
+                    throw new Error(`Synthetic column name(s) collide with real header(s): ${collisions.join(', ')}. ` +
+                        `Rename the synthetic column or use columnOverrides for columns that exist in the DOM.`);
+                }
+                this._headerMap = headerMap;
                 this.log(`Mapped ${entries.length} columns: ${JSON.stringify(entries.map(e => e[0]))}`);
                 return this._headerMap;
             }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { PLAYWRIGHT_SMART_TABLE_VERSION } from './packageVersion';
 export { useTable } from './useTable';
-export type { TableConfig, TableResult, SmartRow, SmartCell, Selector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, } from './types';
+export type { TableConfig, TableResult, SmartRow, SmartCell, Selector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, SyntheticColumnDef, ColumnOverride, ColumnOverrideReadContext, } from './types';
 export { Strategies } from './strategies';
 export * as presets from './presets';
 /** @deprecated Use `presets` instead. Plugins will be removed in v7.0.0. */

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.19.0";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.20.1-next.230dedf";

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.19.0";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.20.1-next.230dedf";

package/dist/plugins/index.d.ts

@@ -23,7 +23,8 @@ export declare const Plugins: {
         debug?: import("..").DebugConfig | undefined;
         onReset?: ((context: import("..").TableContext) => Promise<void>) | undefined;
         strategies?: import("../types").TableStrategies | undefined;
-        columnOverrides?: Partial<Record<string | number | symbol, import("../types").ColumnOverride<any>>> | undefined;
+        columnOverrides?: Partial<Record<string | number | symbol, import("..").ColumnOverride<any>>> | undefined;
+        syntheticColumns?: Record<string, import("..").SyntheticColumnDef<any>> | undefined;
         emptyState?: import("@playwright/test").Locator | undefined;
     };
     /** @deprecated Use `presets.glide` */
@@ -44,7 +45,8 @@ export declare const Plugins: {
         debug?: import("..").DebugConfig | undefined;
         onReset?: ((context: import("..").TableContext) => Promise<void>) | undefined;
         strategies?: import("../types").TableStrategies | undefined;
-        columnOverrides?: Partial<Record<string | number | symbol, import("../types").ColumnOverride<any>>> | undefined;
+        columnOverrides?: Partial<Record<string | number | symbol, import("..").ColumnOverride<any>>> | undefined;
+        syntheticColumns?: Record<string, import("..").SyntheticColumnDef<any>> | undefined;
         emptyState?: import("@playwright/test").Locator | undefined;
     };
     /** @deprecated Use `presets.muiDataGrid` */
@@ -65,7 +67,8 @@ export declare const Plugins: {
         debug?: import("..").DebugConfig | undefined;
         onReset?: ((context: import("..").TableContext) => Promise<void>) | undefined;
         strategies?: import("../types").TableStrategies | undefined;
-        columnOverrides?: Partial<Record<string | number | symbol, import("../types").ColumnOverride<any>>> | undefined;
+        columnOverrides?: Partial<Record<string | number | symbol, import("..").ColumnOverride<any>>> | undefined;
+        syntheticColumns?: Record<string, import("..").SyntheticColumnDef<any>> | undefined;
         emptyState?: import("@playwright/test").Locator | undefined;
     };
 };

package/dist/presets/glide/headers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scrollRightHeader = void 0;
+const debugUtils_1 = require("../../utils/debugUtils");
 /**
  * Scans for headers by finding a scrollable container and setting scrollLeft.
  */
@@ -47,10 +48,12 @@ const scrollRightHeader = async (context, options) => {
         }
     }
     else {
-        console.warn("HeaderStrategies.scrollRight: Could not find scroller. Returning visible headers.");
+        (0, debugUtils_1.logDebug)(config, 'info', "HeaderStrategies.scrollRight: Could not find scroller. Returning visible headers.");
+    }
+    if (isScrollerFound) {
+        await scrollerHandle.evaluate(el => el.scrollLeft = 0);
+        await page.waitForTimeout(200);
     }
-    await scrollerHandle.evaluate(el => el.scrollLeft = 0);
-    await page.waitForTimeout(200);
     return Array.from(collectedHeaders);
 };
 exports.scrollRightHeader = scrollRightHeader;

package/dist/presets/mui.js

@@ -200,7 +200,9 @@ function createMuiDataGrid(opts) {
         strategies: {
             resolveRowIndex: async (row) => {
                 const v = await row.getAttribute('data-rowindex').catch(() => null);
-                return v !== null && !isNaN(Number(v)) ? Number(v) : undefined;
+                if (v === null || isNaN(Number(v)))
+                    return undefined;
+                return { index: Number(v), selector: `[data-rowindex="${v}"]` };
             },
             pagination: {
                 goNext: async (context) => {