@rickcedwhat/playwright-smart-table 6.18.0 → 6.19.0

package/dist/engine/rowFinder.d.ts

@@ -27,4 +27,14 @@ export declare class RowFinder<T = any> {
     }): Promise<SmartRowArray<T>>;
     private findRowLocator;
     private resolveRowIndex;
+    /**
+     * Fallback for findRow when no resolveRowIndex strategy is configured: find the row's
+     * position in the current DOM order in a SINGLE roundtrip. Previously this looped over
+     * every row calling elementHandle() + evaluate() per row (O(n) CDP roundtrips, and
+     * elementHandle() is soft-deprecated). We resolve the target once and let evaluateAll
+     * compare it against the full row set in the browser. The row set is resolved through the
+     * same selector/scope as everywhere else, so a string, function, or Locator rowSelector
+     * all behave identically. (#350)
+     */
+    private scanDomPosition;
 }

package/dist/engine/rowFinder.js

@@ -6,6 +6,7 @@ const smartRowArray_1 = require("../utils/smartRowArray");
 const elementTracker_1 = require("../utils/elementTracker");
 const sentinel_1 = require("../utils/sentinel");
 const navigationBarrier_1 = require("../utils/navigationBarrier");
+const rowResolution_1 = require("./rowResolution");
 class RowFinder {
     constructor(rootLocator, config, resolve, filterEngine, tableMapper, makeSmartRow, tableState = { currentPageIndex: 0 }, advancePage = async () => false) {
         this.rootLocator = rootLocator;
@@ -47,7 +48,7 @@ class RowFinder {
         const tracker = new elementTracker_1.ElementTracker('findRows');
         try {
             const collectMatches = async () => {
-                var _a, _b, _c, _d, _e, _f;
+                var _a, _b;
                 let rowLocators = this.resolve(this.config.rowSelector, this.rootLocator);
                 // Only apply filters if we have them
                 if (Object.keys(filtersRecord).length > 0) {
@@ -56,56 +57,22 @@ class RowFinder {
                 // Get only newly seen matched rows
                 const newIndices = await tracker.getUnseenIndices(rowLocators);
                 const currentRows = await rowLocators.all();
-                const isRowLoading = (_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isRowLoading;
-                const rawRowTimeout = (_c = this.config.strategies.loading) === null || _c === void 0 ? void 0 : _c.rowLoadingTimeout;
-                // undefined = unset (legacy skip); 0 = no wait (immediate check); >0 = wait up to N ms
-                // Non-finite values are treated as unset (defensive guard against Infinity/NaN)
-                const rowLoadingTimeout = rawRowTimeout !== undefined && Number.isFinite(rawRowTimeout) && rawRowTimeout >= 0
-                    ? rawRowTimeout
-                    : 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) {
-                    // Use the configured strategy (O(1), e.g. MUI data-rowindex) when available.
-                    // Without a strategy, fall back to sequential position to avoid the O(n)
-                    // elementHandle scan that resolveRowIndex() would otherwise perform per row.
-                    const rowIndex = this.config.strategies.resolveRowIndex
-                        ? ((_f = await this.config.strategies.resolveRowIndex(currentRows[idx])) !== null && _f !== void 0 ? _f : allRows.length)
-                        : allRows.length;
+                    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);
-                    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)
-                        (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: row ${allRows.length} — waiting up to ${rowLoadingTimeout}ms for row to load`);
-                        const deadline = Date.now() + rowLoadingTimeout;
-                        let resolved = !(await isRowLoading(smartRow)); // immediate check (handles timeout=0)
-                        while (!resolved && Date.now() < deadline) {
-                            await currentRows[idx].page().waitForTimeout(100);
-                            resolved = !(await isRowLoading(smartRow));
-                        }
-                        if (!resolved) {
-                            (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: row ${allRows.length} — still loading after ${rowLoadingTimeout}ms, action: ${onRowLoadingTimeout}`);
-                            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
-                        }
-                        else {
-                            (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: row ${allRows.length} — finished loading`);
+                    // 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}`));
+                    if (loadingOutcome !== 'process') {
+                        barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
+                        if (loadingOutcome === 'throw') {
+                            throw new Error(`[SmartTable] Row ${allRows.length} did not finish loading within ${(_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.rowLoadingTimeout}ms`);
                         }
+                        continue; // 'skip'
                     }
                     allRows.push(smartRow);
                     added++;
@@ -203,19 +170,20 @@ class RowFinder {
             return null;
         }
     }
-    async resolveRowIndex(rowLocator) {
-        if (this.config.strategies.resolveRowIndex) {
-            const result = await this.config.strategies.resolveRowIndex(rowLocator);
-            if (result !== undefined)
-                return result;
-            // Strategy returned undefined — fall through to DOM scan below.
-        }
-        // Fallback: find the row's position in the current DOM order in a SINGLE roundtrip.
-        // Previously this looped over every row calling elementHandle() + evaluate() per row
-        // (O(n) CDP roundtrips, and elementHandle() is soft-deprecated). We now resolve the
-        // target once and let evaluateAll compare it against the full row set in the browser.
-        // The row set is resolved through the same selector/scope as everywhere else, so a
-        // string, function, or Locator rowSelector all behave identically. (#350)
+    resolveRowIndex(rowLocator) {
+        // Shared resolver: resolveRowIndex strategy first, else the DOM-position fallback.
+        return (0, rowResolution_1.resolveLogicalRowIndex)(rowLocator, this.config, () => this.scanDomPosition(rowLocator));
+    }
+    /**
+     * Fallback for findRow when no resolveRowIndex strategy is configured: find the row's
+     * position in the current DOM order in a SINGLE roundtrip. Previously this looped over
+     * every row calling elementHandle() + evaluate() per row (O(n) CDP roundtrips, and
+     * elementHandle() is soft-deprecated). We resolve the target once and let evaluateAll
+     * compare it against the full row set in the browser. The row set is resolved through the
+     * same selector/scope as everywhere else, so a string, function, or Locator rowSelector
+     * all behave identically. (#350)
+     */
+    async scanDomPosition(rowLocator) {
         const targetHandle = await rowLocator.elementHandle();
         if (!targetHandle)
             return undefined;

package/dist/engine/rowResolution.d.ts

@@ -0,0 +1,28 @@
+import type { Locator } from '@playwright/test';
+import type { FinalTableConfig, LoadingStrategy, SmartRow } from '../types';
+/**
+ * Single source of truth for "what is this row's logical index?" (#362 consolidation).
+ *
+ * Uses the configured `resolveRowIndex` strategy when present (e.g. MUI's `data-rowindex`);
+ * 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).
+ */
+export declare function resolveLogicalRowIndex(row: Locator, config: Pick<FinalTableConfig, 'strategies'>, fallback: () => number | undefined | Promise<number | undefined>): Promise<number | undefined>;
+/** What the caller should do with a row after checking its loading state. */
+export type RowLoadingOutcome = 'process' | 'skip' | 'throw';
+/**
+ * Single source of truth for the per-row loading wait (#362 consolidation).
+ *
+ * Collapses the two near-identical blocks in `findRows` (RowFinder) and `runMap`
+ * (tableIteration). The only real difference between the callers is the behavior when no
+ * `rowLoadingTimeout` is configured: `findRows` skips a still-loading row (`noTimeoutAction:
+ * 'skip'`), while `map`/`forEach`/`filter` process it as-is (`'process'`) — and map, in that
+ * case, never even probes `isRowLoading`. Both are preserved exactly.
+ *
+ * The helper never throws and never touches the navigation barrier; it returns a decision so
+ * each caller keeps its own barrier bookkeeping and error message.
+ */
+export declare function resolveRowLoading(row: SmartRow, loading: LoadingStrategy | undefined, noTimeoutAction: 'skip' | 'process', log?: (msg: string) => void): Promise<RowLoadingOutcome>;

package/dist/engine/rowResolution.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLogicalRowIndex = resolveLogicalRowIndex;
+exports.resolveRowLoading = resolveRowLoading;
+/**
+ * Single source of truth for "what is this row's logical index?" (#362 consolidation).
+ *
+ * Uses the configured `resolveRowIndex` strategy when present (e.g. MUI's `data-rowindex`);
+ * 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).
+ */
+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 fallback();
+}
+/**
+ * Single source of truth for the per-row loading wait (#362 consolidation).
+ *
+ * Collapses the two near-identical blocks in `findRows` (RowFinder) and `runMap`
+ * (tableIteration). The only real difference between the callers is the behavior when no
+ * `rowLoadingTimeout` is configured: `findRows` skips a still-loading row (`noTimeoutAction:
+ * 'skip'`), while `map`/`forEach`/`filter` process it as-is (`'process'`) — and map, in that
+ * case, never even probes `isRowLoading`. Both are preserved exactly.
+ *
+ * The helper never throws and never touches the navigation barrier; it returns a decision so
+ * each caller keeps its own barrier bookkeeping and error message.
+ */
+async function resolveRowLoading(row, loading, noTimeoutAction, log) {
+    var _a;
+    const isRowLoading = loading === null || loading === void 0 ? void 0 : loading.isRowLoading;
+    if (!isRowLoading)
+        return 'process';
+    const rawTimeout = loading === null || loading === void 0 ? void 0 : loading.rowLoadingTimeout;
+    // undefined = unset (legacy skip / process-as-is); 0 = one immediate re-check; >0 = poll up to N ms.
+    // Non-finite values are treated as unset (defensive guard against Infinity/NaN).
+    const timeout = rawTimeout !== undefined && Number.isFinite(rawTimeout) && rawTimeout >= 0
+        ? rawTimeout
+        : undefined;
+    // map's fast path: with no timeout and a process-default, it never probes isRowLoading.
+    if (timeout === undefined && noTimeoutAction === 'process')
+        return 'process';
+    if (!(await isRowLoading(row)))
+        return 'process';
+    // Row is loading with no timeout configured → legacy skip (findRows).
+    if (timeout === undefined)
+        return 'skip';
+    log === null || log === void 0 ? void 0 : log(`row ${row.rowIndex} — waiting up to ${timeout}ms for row to load`);
+    const deadline = Date.now() + timeout;
+    let resolved = !(await isRowLoading(row)); // immediate check (handles timeout=0)
+    while (!resolved && Date.now() < deadline) {
+        // Page accessed lazily (only while actually polling), matching the pre-refactor code.
+        await row.page().waitForTimeout(100);
+        resolved = !(await isRowLoading(row));
+    }
+    if (resolved)
+        return 'process';
+    const onTimeout = (_a = loading === null || loading === void 0 ? void 0 : loading.onRowLoadingTimeout) !== null && _a !== void 0 ? _a : 'read-as-is';
+    log === null || log === void 0 ? void 0 : log(`row ${row.rowIndex} — still loading after ${timeout}ms, action: ${onTimeout}`);
+    if (onTimeout === 'skip')
+        return 'skip';
+    if (onTimeout === 'throw')
+        return 'throw';
+    return 'process'; // 'read-as-is'
+}

package/dist/engine/tableIteration.d.ts

@@ -1,5 +1,5 @@
 import type { Locator, Page } from '@playwright/test';
-import type { SmartRow, RowIterationContext, RowIterationOptions } from '../types';
+import type { SmartRow, RowIterationContext, RowIterationOptions, TableContext } from '../types';
 import type { FinalTableConfig } from '../types';
 import type { SmartRowArray } from '../utils/smartRowArray';
 import { NavigationBarrier } from '../utils/navigationBarrier';
@@ -12,6 +12,8 @@ export interface TableIterationEnv<T = any> {
     config: FinalTableConfig<T>;
     getPage: () => Page;
     getCurrentPageIndex: () => number;
+    /** Builds a TableContext for strategy calls (e.g. the viewport visible-row oracle). */
+    getContext: () => TableContext;
 }
 /** Delegates to {@link runMap}; void results are discarded. */
 export declare function runForEach<T>(env: TableIterationEnv<T>, callback: (ctx: RowIterationContext<T>) => void | Promise<void>, options?: RowIterationOptions): Promise<void>;

package/dist/engine/tableIteration.js

@@ -7,6 +7,7 @@ const elementTracker_1 = require("../utils/elementTracker");
 const debugUtils_1 = require("../utils/debugUtils");
 const navigationBarrier_1 = require("../utils/navigationBarrier");
 const mutex_1 = require("../utils/mutex");
+const rowResolution_1 = require("./rowResolution");
 function log(config, msg) {
     (0, debugUtils_1.logDebug)(config, 'verbose', msg);
 }
@@ -20,7 +21,7 @@ async function runForEach(env, callback, options = {}) {
  * Concurrency: `parallel` | `synchronized` | `sequential` (see RowIterationOptions).
  */
 async function runMap(env, callback, options = {}, label = 'map') {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e, _f;
     const map = env.getMap();
     const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : env.config.maxPages;
     const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : env.config.strategies.dedupe;
@@ -34,21 +35,6 @@ async function runMap(env, callback, options = {}, label = 'map') {
     const useMutex = concurrency === 'sequential';
     const useBulk = (_e = options.useBulkPagination) !== null && _e !== void 0 ? _e : false;
     const tracker = new elementTracker_1.ElementTracker(label);
-    // Row-level loading gate (Bug #355). Must run BEFORE the dedupe strategy so
-    // content-based dedupe keys are computed on the row's final loaded state — a key
-    // computed on a skeleton changes once the row loads, and the ElementTracker
-    // re-flags the row (text signature changed), producing duplicates.
-    // Semantics mirror findRows (rowFinder.ts), with one deliberate difference:
-    // findRows drops loading rows when no timeout is set (legacy skip), but map/forEach
-    // historically visited every row — so without a timeout we process the row as-is.
-    const isRowLoading = (_f = env.config.strategies.loading) === null || _f === void 0 ? void 0 : _f.isRowLoading;
-    const rawRowTimeout = (_g = env.config.strategies.loading) === null || _g === void 0 ? void 0 : _g.rowLoadingTimeout;
-    // undefined = unset (process as-is); 0 = no wait (immediate re-check); >0 = wait up to N ms
-    // Non-finite values are treated as unset (defensive guard against Infinity/NaN)
-    const rowLoadingTimeout = rawRowTimeout !== undefined && Number.isFinite(rawRowTimeout) && rawRowTimeout >= 0
-        ? rawRowTimeout
-        : undefined;
-    const onRowLoadingTimeout = (_j = (_h = env.config.strategies.loading) === null || _h === void 0 ? void 0 : _h.onRowLoadingTimeout) !== null && _j !== void 0 ? _j : 'read-as-is';
     log(env.config, `${label}: starting (maxPages=${effectiveMaxPages}, mode=${concurrency}, dedupe=${!!dedupeStrategy})`);
     const results = [];
     try {
@@ -67,12 +53,26 @@ async function runMap(env, callback, options = {}, label = 'map') {
             const rowLocators = env.getRowLocators();
             const allIndices = await tracker.peekUnseenIndices(rowLocators);
             const pageRows = await rowLocators.all();
+            // A2 (#353 part 2 / #357): when the viewport can report which rows are within the visible
+            // bounds, drop overscan rows from collection. They are left uncommitted (still unseen), so
+            // 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.
+            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));
+                if (candidateIndices.length !== allIndices.length) {
+                    log(env.config, `${label}: viewport visible filter — ${candidateIndices.length}/${allIndices.length} row(s) in view`);
+                }
+            }
             // In synchronized mode, overscan rows rendered beyond the visible viewport by virtual
             // scrollers can be evicted when the horizontal barrier fires snapFirstColumnIntoView.
             // Filter them out before committing so they stay unseen and are picked up on the next page.
             const newIndices = concurrency === 'synchronized'
-                ? (await Promise.all(allIndices.map(async (idx) => ({ idx, present: pageRows[idx] != null && (await pageRows[idx].count()) > 0 })))).filter(r => r.present).map(r => r.idx)
-                : allIndices;
+                ? (await Promise.all(candidateIndices.map(async (idx) => ({ idx, present: pageRows[idx] != null && (await pageRows[idx].count()) > 0 })))).filter(r => r.present).map(r => r.idx)
+                : candidateIndices;
             await tracker.commitIndices(rowLocators, newIndices);
             const batchSize = newIndices.length;
             if (batchSize === 0) {
@@ -82,30 +82,36 @@ async function runMap(env, callback, options = {}, label = 'map') {
                 log(env.config, `${label}: scanning page ${pagesScanned} — ${batchSize} new row(s)`);
                 const barrier = useBarrier ? new navigationBarrier_1.NavigationBarrier(batchSize) : undefined;
                 const actionMutex = useMutex ? new mutex_1.Mutex() : null;
-                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i, env.getCurrentPageIndex(), barrier));
-                const processRow = async (row) => {
+                // `index` (ctx.index) is the enumeration counter — the order rows are visited,
+                // contiguous and monotonic. It drives the internal stop()/ordering logic.
+                const positionBase = rowIndex;
+                // B-hybrid (#362): the row's rowIndex is its logical/data-model index when a
+                // resolveRowIndex strategy is configured (so bringIntoView and position math are
+                // 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);
+                    // 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;
+                    return sr;
+                }));
+                // enumIndex = visit-order counter (ctx.index); row.rowIndex = logical (ctx.rowIndex).
+                const processRow = async (row, enumIndex) => {
+                    var _a;
                     try {
-                        if (stopped && row.rowIndex > stoppedIndex) {
+                        if (stopped && enumIndex > stoppedIndex) {
                             return SKIP;
                         }
                         // Wait for the row to finish loading BEFORE evaluating its dedupe key (Bug #355).
-                        if (isRowLoading && rowLoadingTimeout !== undefined && await isRowLoading(row)) {
-                            log(env.config, `${label}: row ${row.rowIndex} — waiting up to ${rowLoadingTimeout}ms for row to load`);
-                            const deadline = Date.now() + rowLoadingTimeout;
-                            let resolved = !(await isRowLoading(row)); // immediate check (handles timeout=0)
-                            while (!resolved && Date.now() < deadline) {
-                                await env.getPage().waitForTimeout(100);
-                                resolved = !(await isRowLoading(row));
-                            }
-                            if (!resolved) {
-                                log(env.config, `${label}: row ${row.rowIndex} — still loading after ${rowLoadingTimeout}ms, action: ${onRowLoadingTimeout}`);
-                                if (onRowLoadingTimeout === 'skip')
-                                    return SKIP;
-                                if (onRowLoadingTimeout === 'throw') {
-                                    throw new Error(`[SmartTable] Row ${row.rowIndex} did not finish loading within ${rowLoadingTimeout}ms`);
-                                }
-                                // 'read-as-is': fall through and process the row
-                            }
+                        // map/forEach/filter process a still-loading row when no timeout is set (unlike
+                        // findRows, which skips) — see resolveRowLoading's `noTimeoutAction`.
+                        const loadingOutcome = await (0, rowResolution_1.resolveRowLoading)(row, env.config.strategies.loading, 'process', (msg) => log(env.config, `${label}: ${msg}`));
+                        if (loadingOutcome === 'skip')
+                            return SKIP;
+                        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`);
                         }
                         if (dedupeKeys && dedupeStrategy) {
                             const key = await dedupeStrategy(row);
@@ -117,10 +123,10 @@ async function runMap(env, callback, options = {}, label = 'map') {
                         }
                         // Execute callback (optionally serialized via mutex)
                         const runCallback = async () => {
-                            if (stopped && row.rowIndex > stoppedIndex)
+                            if (stopped && enumIndex > stoppedIndex)
                                 return SKIP;
-                            log(env.config, `${label}: processing row ${row.rowIndex}`);
-                            return await callback({ row, index: row.rowIndex, rowIndex: row.rowIndex, pageIndex: env.getCurrentPageIndex(), stop: () => stop(row.rowIndex) });
+                            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);
@@ -136,16 +142,16 @@ async function runMap(env, callback, options = {}, label = 'map') {
                 };
                 const pageResults = [];
                 if (concurrency === 'sequential') {
-                    for (const row of smartRows) {
-                        pageResults.push(await processRow(row));
+                    for (let i = 0; i < smartRows.length; i++) {
+                        pageResults.push(await processRow(smartRows[i], positionBase + i));
                     }
                 }
                 else {
-                    const results = await Promise.all(smartRows.map(processRow));
+                    const results = await Promise.all(smartRows.map((row, i) => processRow(row, positionBase + i)));
                     pageResults.push(...results);
                 }
                 for (let i = 0; i < pageResults.length; i++) {
-                    if (smartRows[i].rowIndex > stoppedIndex)
+                    if (positionBase + i > stoppedIndex)
                         break;
                     const r = pageResults[i];
                     if (r !== SKIP)

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.18.0";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.19.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.18.0";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.19.0";

package/dist/plugins/index.d.ts

@@ -24,6 +24,7 @@ export declare const Plugins: {
         onReset?: ((context: import("..").TableContext) => Promise<void>) | undefined;
         strategies?: import("../types").TableStrategies | undefined;
         columnOverrides?: Partial<Record<string | number | symbol, import("../types").ColumnOverride<any>>> | undefined;
+        emptyState?: import("@playwright/test").Locator | undefined;
     };
     /** @deprecated Use `presets.glide` */
     Glide: {
@@ -44,6 +45,7 @@ export declare const Plugins: {
         onReset?: ((context: import("..").TableContext) => Promise<void>) | undefined;
         strategies?: import("../types").TableStrategies | undefined;
         columnOverrides?: Partial<Record<string | number | symbol, import("../types").ColumnOverride<any>>> | undefined;
+        emptyState?: import("@playwright/test").Locator | undefined;
     };
     /** @deprecated Use `presets.muiDataGrid` */
     MUI: {
@@ -64,5 +66,6 @@ export declare const Plugins: {
         onReset?: ((context: import("..").TableContext) => Promise<void>) | undefined;
         strategies?: import("../types").TableStrategies | undefined;
         columnOverrides?: Partial<Record<string | number | symbol, import("../types").ColumnOverride<any>>> | undefined;
+        emptyState?: import("@playwright/test").Locator | undefined;
     };
 };

package/dist/presets/mui.js

@@ -353,6 +353,31 @@ function createMuiDataGrid(opts) {
                         return { first: Math.min(...indices), last: Math.max(...indices) };
                     }, rowSel);
                 },
+                // Geometry-based visible-row set for the iteration engine (A2, #353/#357). Returns
+                // the DOM positions of rows overlapping the virtualScroller's bounds so map/forEach
+                // skip the overscan rows MUI keeps mounted above/below the fold. The scroller is a
+                // descendant of root, so querySelector (not closest).
+                getVisibleRowIndices: async ({ root, config }) => {
+                    const rowSel = config.rowSelector;
+                    return root.evaluate((el, rowSel) => {
+                        const scroller = el.querySelector('.MuiDataGrid-virtualScroller');
+                        const rows = Array.from(el.querySelectorAll(rowSel));
+                        const scrollerRect = scroller ? scroller.getBoundingClientRect() : null;
+                        const visible = [];
+                        rows.forEach((r, i) => {
+                            if (!scrollerRect) {
+                                visible.push(i);
+                                return;
+                            } // can't measure → keep all
+                            const rect = r.getBoundingClientRect();
+                            if (rect.height === 0)
+                                return;
+                            if (rect.bottom > scrollerRect.top && rect.top < scrollerRect.bottom)
+                                visible.push(i);
+                        });
+                        return visible;
+                    }, rowSel);
+                },
                 getVisibleColumnRange: async ({ root, config }) => {
                     const rowSel = config.rowSelector;
                     const cellSel = typeof config.cellSelector === 'string' ? config.cellSelector : '[aria-colindex]';