@rickcedwhat/playwright-smart-table 6.8.2 → 6.10.0

package/README.md

@@ -106,8 +106,6 @@ When your pagination strategy supports bulk jumps (`goNextBulk`), pass `{ useBul
 > **`map` + UI interactions:** `map` defaults to `concurrency: 'parallel'`. If your callback opens popovers,
 > fills inputs, or otherwise mutates UI state, pass `{ concurrency: 'sequential' }` (or `'synchronized'` if you need lock-step navigation with serialized work).
 
-The legacy `{ parallel: true | false }` option still works but is deprecated; prefer `concurrency`.
-
 ### `filter` vs `findRows`
 
 | Use case | Best tool |

package/dist/engine/rowFinder.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RowFinder = void 0;
 const debugUtils_1 = require("../utils/debugUtils");
@@ -28,175 +19,169 @@ class RowFinder {
     log(msg) {
         (0, debugUtils_1.logDebug)(this.config, 'verbose', msg);
     }
-    findRow(filters_1) {
-        return __awaiter(this, arguments, void 0, function* (filters, options = {}) {
-            (0, debugUtils_1.logDebug)(this.config, 'info', 'Searching for row', filters);
-            yield this.tableMapper.getMap();
-            const rowLocator = yield this.findRowLocator(filters, options);
-            if (rowLocator) {
-                (0, debugUtils_1.logDebug)(this.config, 'info', 'Row found');
-                yield (0, debugUtils_1.debugDelay)(this.config, 'findRow');
-                return this.makeSmartRow(rowLocator, yield this.tableMapper.getMap(), 0);
-            }
-            (0, debugUtils_1.logDebug)(this.config, 'error', 'Row not found', filters);
-            yield (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, yield this.tableMapper.getMap(), 0);
-            smartRow[sentinel_1.SENTINEL_ROW] = true;
-            return smartRow;
-        });
+    async findRow(filters, options = {}) {
+        (0, debugUtils_1.logDebug)(this.config, 'info', 'Searching for row', filters);
+        await this.tableMapper.getMap();
+        const rowLocator = await this.findRowLocator(filters, options);
+        if (rowLocator) {
+            (0, debugUtils_1.logDebug)(this.config, 'info', 'Row found');
+            await (0, debugUtils_1.debugDelay)(this.config, 'findRow');
+            return this.makeSmartRow(rowLocator, await this.tableMapper.getMap(), 0);
+        }
+        (0, debugUtils_1.logDebug)(this.config, 'error', 'Row not found', filters);
+        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);
+        smartRow[sentinel_1.SENTINEL_ROW] = true;
+        return smartRow;
     }
-    findRows() {
-        return __awaiter(this, arguments, void 0, function* (filters = {}, options) {
-            var _a, _b, _c, _d;
-            const filtersRecord = filters;
-            const map = yield this.tableMapper.getMap();
-            const allRows = [];
-            const effectiveMaxPages = (_b = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages) !== null && _b !== void 0 ? _b : Infinity;
-            let pagesScanned = 1;
-            this.log(`findRows: starting (maxPages=${effectiveMaxPages}, filters=${JSON.stringify(filtersRecord)})`);
-            const tracker = new elementTracker_1.ElementTracker('findRows');
-            try {
-                const collectMatches = () => __awaiter(this, void 0, void 0, function* () {
-                    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) {
-                        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);
-                    }
-                    // Get only newly seen matched rows
-                    const newIndices = yield tracker.getUnseenIndices(rowLocators);
-                    const currentRows = yield rowLocators.all();
-                    const isRowLoading = (_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isRowLoading;
-                    let added = 0;
-                    for (const idx of newIndices) {
-                        const smartRow = this.makeSmartRow(currentRows[idx], map, allRows.length, this.tableState.currentPageIndex);
-                        if (isRowLoading && (yield isRowLoading(smartRow))) {
-                            this.log(`findRows: page ${this.tableState.currentPageIndex} — row skipped (isRowLoading=true)`);
-                            continue;
-                        }
-                        allRows.push(smartRow);
-                        added++;
-                    }
-                    this.log(`findRows: page ${this.tableState.currentPageIndex} — ${added} new match(es) (total: ${allRows.length})`);
-                });
-                // Scan first page
-                yield 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;
-                    if ((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk) {
-                        paginationResult = yield this.config.strategies.pagination.goNextBulk(context);
-                    }
-                    else if ((_d = this.config.strategies.pagination) === null || _d === void 0 ? void 0 : _d.goNext) {
-                        paginationResult = yield this.config.strategies.pagination.goNext(context);
-                    }
-                    else {
-                        this.log(`findRows: no pagination primitive — stopping`);
-                        break;
-                    }
-                    const didPaginate = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
-                    if (!didPaginate) {
-                        this.log(`findRows: pagination returned false — end of data`);
-                        break;
+    async findRows(filters = {}, options) {
+        var _a, _b, _c, _d;
+        const filtersRecord = filters;
+        const map = await this.tableMapper.getMap();
+        const allRows = [];
+        const effectiveMaxPages = (_b = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages) !== null && _b !== void 0 ? _b : Infinity;
+        let pagesScanned = 1;
+        this.log(`findRows: starting (maxPages=${effectiveMaxPages}, filters=${JSON.stringify(filtersRecord)})`);
+        const tracker = new elementTracker_1.ElementTracker('findRows');
+        try {
+            const collectMatches = async () => {
+                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) {
+                    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);
+                }
+                // 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;
+                let added = 0;
+                for (const idx of newIndices) {
+                    const smartRow = this.makeSmartRow(currentRows[idx], map, allRows.length, this.tableState.currentPageIndex);
+                    if (isRowLoading && await isRowLoading(smartRow)) {
+                        this.log(`findRows: page ${this.tableState.currentPageIndex} — row skipped (isRowLoading=true)`);
+                        continue;
                     }
-                    const pagesJumped = typeof paginationResult === 'number' ? paginationResult : 1;
-                    this.tableState.currentPageIndex += pagesJumped;
-                    pagesScanned += pagesJumped;
-                    this.log(`findRows: advanced ${pagesJumped} page(s), now at page ${this.tableState.currentPageIndex}`);
-                    yield collectMatches();
+                    allRows.push(smartRow);
+                    added++;
                 }
+                this.log(`findRows: page ${this.tableState.currentPageIndex} — ${added} new match(es) (total: ${allRows.length})`);
+            };
+            // Scan first page
+            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;
+                if ((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk) {
+                    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 {
+                    this.log(`findRows: no pagination primitive — stopping`);
+                    break;
+                }
+                const didPaginate = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
+                if (!didPaginate) {
+                    this.log(`findRows: pagination returned false — end of data`);
+                    break;
+                }
+                const pagesJumped = typeof paginationResult === 'number' ? paginationResult : 1;
+                this.tableState.currentPageIndex += pagesJumped;
+                pagesScanned += pagesJumped;
+                this.log(`findRows: advanced ${pagesJumped} page(s), now at page ${this.tableState.currentPageIndex}`);
+                await collectMatches();
             }
-            finally {
-                yield tracker.cleanup(this.rootLocator.page());
-            }
-            this.log(`findRows: done — ${allRows.length} row(s) collected across ${pagesScanned} page(s)`);
-            return (0, smartRowArray_1.createSmartRowArray)(allRows);
-        });
+        }
+        finally {
+            await tracker.cleanup(this.rootLocator.page());
+        }
+        this.log(`findRows: done — ${allRows.length} row(s) collected across ${pagesScanned} page(s)`);
+        return (0, smartRowArray_1.createSmartRowArray)(allRows);
     }
-    findRowLocator(filters_1) {
-        return __awaiter(this, arguments, void 0, function* (filters, options = {}) {
-            var _a, _b, _c, _d;
-            const map = yield this.tableMapper.getMap();
-            const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages;
-            let pagesScanned = 1;
-            this.log(`Looking for row: ${JSON.stringify(filters)} (MaxPages: ${effectiveMaxPages})`);
-            while (true) {
-                // Check Loading
-                if ((_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isTableLoading) {
-                    const isLoading = yield this.config.strategies.loading.isTableLoading({
-                        root: this.rootLocator,
-                        config: this.config,
-                        page: this.rootLocator.page(),
-                        resolve: this.resolve
-                    });
-                    if (isLoading) {
-                        this.log('Table is loading... waiting');
-                        yield this.rootLocator.page().waitForTimeout(200);
-                        continue;
-                    }
+    async findRowLocator(filters, options = {}) {
+        var _a, _b, _c, _d;
+        const map = await this.tableMapper.getMap();
+        const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages;
+        let pagesScanned = 1;
+        this.log(`Looking for row: ${JSON.stringify(filters)} (MaxPages: ${effectiveMaxPages})`);
+        while (true) {
+            // Check Loading
+            if ((_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isTableLoading) {
+                const isLoading = await this.config.strategies.loading.isTableLoading({
+                    root: this.rootLocator,
+                    config: this.config,
+                    page: this.rootLocator.page(),
+                    resolve: this.resolve
+                });
+                if (isLoading) {
+                    this.log('Table is loading... waiting');
+                    await this.rootLocator.page().waitForTimeout(200);
+                    continue;
                 }
-                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 = yield matchedRows.count();
-                this.log(`Page ${this.tableState.currentPageIndex}: Found ${count} matches.`);
-                if (count > 1) {
-                    const sampleData = [];
-                    try {
-                        const firstFewRows = yield matchedRows.all();
-                        const sampleCount = Math.min(firstFewRows.length, 3);
-                        for (let i = 0; i < sampleCount; i++) {
-                            const rowData = yield this.makeSmartRow(firstFewRows[i], map, 0, this.tableState.currentPageIndex).toJSON();
-                            sampleData.push(JSON.stringify(rowData));
-                        }
+            }
+            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();
+            this.log(`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}`);
                 }
-                if (count === 1)
-                    return matchedRows.first();
-                if (pagesScanned < effectiveMaxPages) {
-                    this.log(`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;
-                    if ((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk) {
-                        paginationResult = yield this.config.strategies.pagination.goNextBulk(context);
-                    }
-                    else if ((_d = this.config.strategies.pagination) === null || _d === void 0 ? void 0 : _d.goNext) {
-                        paginationResult = yield this.config.strategies.pagination.goNext(context);
-                    }
-                    else {
-                        this.log(`Page ${this.tableState.currentPageIndex}: Pagination failed (no goNext or goNextBulk primitive).`);
-                        return null;
-                    }
-                    const didLoadMore = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
-                    if (didLoadMore) {
-                        const pagesJumped = typeof paginationResult === 'number' ? paginationResult : 1;
-                        this.tableState.currentPageIndex += pagesJumped;
-                        pagesScanned += pagesJumped;
-                        continue;
-                    }
-                    else {
-                        this.log(`Page ${this.tableState.currentPageIndex}: Pagination failed (end of data).`);
-                    }
+                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}`);
+            }
+            if (count === 1)
+                return matchedRows.first();
+            if (pagesScanned < effectiveMaxPages) {
+                this.log(`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;
+                if ((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk) {
+                    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 {
+                    this.log(`Page ${this.tableState.currentPageIndex}: Pagination failed (no goNext or goNextBulk primitive).`);
+                    return null;
+                }
+                const didLoadMore = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
+                if (didLoadMore) {
+                    const pagesJumped = typeof paginationResult === 'number' ? paginationResult : 1;
+                    this.tableState.currentPageIndex += pagesJumped;
+                    pagesScanned += pagesJumped;
+                    continue;
+                }
+                else {
+                    this.log(`Page ${this.tableState.currentPageIndex}: Pagination failed (end of data).`);
                 }
-                return null;
             }
-        });
+            return null;
+        }
     }
 }
 exports.RowFinder = RowFinder;

package/dist/engine/tableIteration.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runForEach = runForEach;
 exports.runMap = runMap;
@@ -21,137 +12,128 @@ function log(config, msg) {
 }
 const SKIP = Symbol('skip');
 /** Delegates to {@link runMap}; void results are discarded. */
-function runForEach(env_1, callback_1) {
-    return __awaiter(this, arguments, void 0, function* (env, callback, options = {}) {
-        yield runMap(env, callback, options, 'forEach');
-    });
+async function runForEach(env, callback, options = {}) {
+    await runMap(env, callback, options, 'forEach');
 }
 /**
  * Row iteration for map (and forEach/filter via label).
  * Concurrency: `parallel` | `synchronized` | `sequential` (see RowIterationOptions).
  */
-function runMap(env_1, callback_1) {
-    return __awaiter(this, arguments, void 0, function* (env, callback, options = {}, label = 'map') {
-        var _a, _b, _c;
-        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;
-        const dedupeKeys = dedupeStrategy ? new Set() : null;
-        const defaultMode = label === 'map' ? 'parallel' : 'sequential';
-        const concurrency = options.concurrency ||
-            (options.parallel === true ? 'parallel' :
-                options.parallel === false ? 'sequential' :
-                    env.config.concurrency || defaultMode);
-        const useBarrier = concurrency !== 'sequential';
-        // Mutex must not pair with the navigation barrier: synchronized mode needs every row
-        // to enter barrier.sync concurrently; serializing callbacks here deadlocks (first row waits
-        // for batchSize peers that never reach the barrier).
-        const useMutex = concurrency === 'sequential';
-        const useBulk = (_c = options.useBulkPagination) !== null && _c !== void 0 ? _c : false;
-        const tracker = new elementTracker_1.ElementTracker(label);
-        log(env.config, `${label}: starting (maxPages=${effectiveMaxPages}, mode=${concurrency}, dedupe=${!!dedupeStrategy})`);
-        const results = [];
-        try {
-            let rowIndex = 0;
-            let stopped = false;
-            let stoppedIndex = Infinity;
-            let pagesScanned = 1;
-            const stop = (idx) => {
-                if (!stopped) {
-                    log(env.config, `${label}: stop() called at row ${idx} — halting`);
-                    stopped = true;
-                    stoppedIndex = idx;
-                }
-            };
-            while (!stopped) {
-                const rowLocators = env.getRowLocators();
-                const newIndices = yield tracker.getUnseenIndices(rowLocators);
-                const pageRows = yield rowLocators.all();
-                const batchSize = newIndices.length;
-                if (batchSize === 0) {
-                    log(env.config, `${label}: page ${pagesScanned} — no new row(s) found`);
-                }
-                else {
-                    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, pagesScanned - 1, barrier));
-                    const processRow = (row) => __awaiter(this, void 0, void 0, function* () {
-                        try {
-                            if (stopped && row.rowIndex > stoppedIndex) {
+async function runMap(env, callback, options = {}, label = 'map') {
+    var _a, _b, _c, _d, _e;
+    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;
+    const dedupeKeys = dedupeStrategy ? new Set() : null;
+    const defaultMode = label === 'map' ? 'parallel' : 'sequential';
+    const concurrency = (_d = (_c = options.concurrency) !== null && _c !== void 0 ? _c : env.config.concurrency) !== null && _d !== void 0 ? _d : defaultMode;
+    const useBarrier = concurrency !== 'sequential';
+    // Mutex must not pair with the navigation barrier: synchronized mode needs every row
+    // to enter barrier.sync concurrently; serializing callbacks here deadlocks (first row waits
+    // for batchSize peers that never reach the barrier).
+    const useMutex = concurrency === 'sequential';
+    const useBulk = (_e = options.useBulkPagination) !== null && _e !== void 0 ? _e : false;
+    const tracker = new elementTracker_1.ElementTracker(label);
+    log(env.config, `${label}: starting (maxPages=${effectiveMaxPages}, mode=${concurrency}, dedupe=${!!dedupeStrategy})`);
+    const results = [];
+    try {
+        let rowIndex = 0;
+        let stopped = false;
+        let stoppedIndex = Infinity;
+        let pagesScanned = 1;
+        const stop = (idx) => {
+            if (!stopped) {
+                log(env.config, `${label}: stop() called at row ${idx} — halting`);
+                stopped = true;
+                stoppedIndex = idx;
+            }
+        };
+        while (!stopped) {
+            const rowLocators = env.getRowLocators();
+            const newIndices = await tracker.getUnseenIndices(rowLocators);
+            const pageRows = await rowLocators.all();
+            const batchSize = newIndices.length;
+            if (batchSize === 0) {
+                log(env.config, `${label}: page ${pagesScanned} — no new row(s) found`);
+            }
+            else {
+                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, pagesScanned - 1, barrier));
+                const processRow = async (row) => {
+                    try {
+                        if (stopped && row.rowIndex > stoppedIndex) {
+                            return SKIP;
+                        }
+                        if (dedupeKeys && dedupeStrategy) {
+                            const key = await dedupeStrategy(row);
+                            if (dedupeKeys.has(key)) {
+                                log(env.config, `${label}: dedupe skip key="${key}"`);
                                 return SKIP;
                             }
-                            if (dedupeKeys && dedupeStrategy) {
-                                const key = yield dedupeStrategy(row);
-                                if (dedupeKeys.has(key)) {
-                                    log(env.config, `${label}: dedupe skip key="${key}"`);
-                                    return SKIP;
-                                }
-                                dedupeKeys.add(key);
-                            }
-                            // Execute callback (optionally serialized via mutex)
-                            const runCallback = () => __awaiter(this, void 0, void 0, function* () {
-                                if (stopped && row.rowIndex > stoppedIndex)
-                                    return SKIP;
-                                log(env.config, `${label}: processing row ${row.rowIndex}`);
-                                return yield callback({ row, rowIndex: row.rowIndex, stop: () => stop(row.rowIndex) });
-                            });
-                            if (actionMutex) {
-                                return yield actionMutex.run(runCallback);
-                            }
-                            else {
-                                return yield runCallback();
-                            }
+                            dedupeKeys.add(key);
                         }
-                        finally {
-                            // Ensure the barrier is notified once per row, even on error or skip.
-                            barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
+                        // Execute callback (optionally serialized via mutex)
+                        const runCallback = async () => {
+                            if (stopped && row.rowIndex > stoppedIndex)
+                                return SKIP;
+                            log(env.config, `${label}: processing row ${row.rowIndex}`);
+                            return await callback({ row, rowIndex: row.rowIndex, stop: () => stop(row.rowIndex) });
+                        };
+                        if (actionMutex) {
+                            return await actionMutex.run(runCallback);
                         }
-                    });
-                    const pageResults = [];
-                    if (concurrency === 'sequential') {
-                        for (const row of smartRows) {
-                            pageResults.push(yield processRow(row));
+                        else {
+                            return await runCallback();
                         }
                     }
-                    else {
-                        const results = yield Promise.all(smartRows.map(processRow));
-                        pageResults.push(...results);
+                    finally {
+                        // Ensure the barrier is notified once per row, even on error or skip.
+                        barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
                     }
-                    for (let i = 0; i < pageResults.length; i++) {
-                        if (smartRows[i].rowIndex > stoppedIndex)
-                            break;
-                        const r = pageResults[i];
-                        if (r !== SKIP)
-                            results.push(r);
+                };
+                const pageResults = [];
+                if (concurrency === 'sequential') {
+                    for (const row of smartRows) {
+                        pageResults.push(await processRow(row));
                     }
-                    rowIndex += batchSize;
                 }
-                if (stopped || pagesScanned >= effectiveMaxPages)
-                    break;
-                log(env.config, `${label}: advancing to next page (${pagesScanned} → ${pagesScanned + 1})`);
-                if (!(yield env.advancePage(useBulk))) {
-                    log(env.config, `${label}: no more pages — done`);
-                    break;
+                else {
+                    const results = await Promise.all(smartRows.map(processRow));
+                    pageResults.push(...results);
                 }
-                pagesScanned++;
+                for (let i = 0; i < pageResults.length; i++) {
+                    if (smartRows[i].rowIndex > stoppedIndex)
+                        break;
+                    const r = pageResults[i];
+                    if (r !== SKIP)
+                        results.push(r);
+                }
+                rowIndex += batchSize;
             }
-            log(env.config, `${label}: complete — ${results.length} result(s) across ${pagesScanned} page(s)`);
-        }
-        finally {
-            yield tracker.cleanup(env.getPage());
+            if (stopped || pagesScanned >= effectiveMaxPages)
+                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;
+            }
+            pagesScanned++;
         }
-        return results;
-    });
+        log(env.config, `${label}: complete — ${results.length} result(s) across ${pagesScanned} page(s)`);
+    }
+    finally {
+        await tracker.cleanup(env.getPage());
+    }
+    return results;
 }
 /** Filter via map; returns matched rows as {@link SmartRowArray}. */
-function runFilter(env_1, predicate_1) {
-    return __awaiter(this, arguments, void 0, function* (env, predicate, options = {}) {
-        const mapCallback = (ctx) => __awaiter(this, void 0, void 0, function* () {
-            const matched = yield predicate(ctx);
-            return matched ? ctx.row : SKIP;
-        });
-        const results = yield runMap(env, mapCallback, options, 'filter');
-        return env.createSmartRowArray(results);
-    });
+async function runFilter(env, predicate, options = {}) {
+    const mapCallback = async (ctx) => {
+        const matched = await predicate(ctx);
+        return matched ? ctx.row : SKIP;
+    };
+    const results = await runMap(env, mapCallback, options, 'filter');
+    return env.createSmartRowArray(results);
 }