@rickcedwhat/playwright-smart-table 6.7.8 → 6.8.0

package/README.md

@@ -40,10 +40,10 @@ const email = await row.locator('td').nth(emailIndex).textContent();
 
 ```typescript
 // ✅ Column-aware - survives column reordering
-const row = await table.findRow({ Name: 'John Doe' });
+const row = table.getRow({ Name: 'John Doe' });
 const email = await row.getCell('Email').textContent();
 
-// ✅ Auto-pagination
+// ✅ Auto-pagination across all pages
 const allEngineers = await table.findRows({ Department: 'Engineering' });
 
 // ✅ Type-safe
@@ -66,8 +66,8 @@ import { useTable } from '@rickcedwhat/playwright-smart-table';
 
 const table = await useTable(page.locator('#my-table')).init();
 
-// Find row by column values
-const row = await table.findRow({ Name: 'John Doe' });
+// Get row by column values (current page)
+const row = table.getRow({ Name: 'John Doe' });
 
 // Access cells by column name
 const email = await row.getCell('Email').innerText();
@@ -79,16 +79,16 @@ const allActive = await table.findRows({ Status: 'Active' });
 ### Iterating Across Pages
 
 ```typescript
-// forEach — sequential, safe for interactions (parallel: false default)
+// forEach — sequential by default (concurrency: 'sequential') — safe for interactions
 await table.forEach(async ({ row, rowIndex, stop }) => {
   if (await row.getCell('Status').innerText() === 'Done') stop();
   await row.getCell('Checkbox').click();
 });
 
-// map — parallel within page, safe for reads (parallel: true default)
+// map — parallel by default (concurrency: 'parallel') — safe for reads
 const emails = await table.map(({ row }) => row.getCell('Email').innerText());
 
-// filter — async predicate across all pages, returns SmartRowArray
+// filter — sequential by default; returns SmartRowArray
 const active = await table.filter(async ({ row }) =>
   await row.getCell('Status').innerText() === 'Active'
 );
@@ -99,10 +99,14 @@ for await (const { row, rowIndex } of table) {
 }
 ```
 
+Set a default for all iteration calls with `useTable(..., { concurrency: 'sequential' })`, or per call: `table.map(fn, { concurrency: 'synchronized' })`. Modes: **`parallel`** (full parallelism), **`sequential`** (strictly one row at a time), **`synchronized`** (parallel navigation with serialized callbacks — useful for virtualized grids).
+
 When your pagination strategy supports bulk jumps (`goNextBulk`), pass `{ useBulkPagination: true }` to `map`/`forEach`/`filter` to advance by multiple pages at once.
 
-> **`map` + UI interactions:** `map` defaults to `parallel: true`. If your callback opens popovers,
-> fills inputs, or otherwise mutates UI state, pass `{ parallel: false }` to avoid overlapping interactions.
+> **`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`
 

package/dist/engine/tableIteration.d.ts

@@ -2,24 +2,22 @@ import type { Locator, Page } from '@playwright/test';
 import type { SmartRow, RowIterationContext, RowIterationOptions } from '../types';
 import type { FinalTableConfig } from '../types';
 import type { SmartRowArray } from '../utils/smartRowArray';
+import { NavigationBarrier } from '../utils/navigationBarrier';
 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) => SmartRow<T>;
+    makeSmartRow: (rowLocator: Locator, map: Map<string, number>, rowIndex: number, tablePageIndex?: number, barrier?: NavigationBarrier) => SmartRow<T>;
     createSmartRowArray: (rows: SmartRow<T>[]) => SmartRowArray<T>;
     config: FinalTableConfig<T>;
     getPage: () => Page;
 }
-/**
- * Shared row-iteration loop used by forEach, map, and filter.
- */
+/** 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>;
 /**
- * Shared row-iteration loop for map.
- */
-export declare function runMap<T, R>(env: TableIterationEnv<T>, callback: (ctx: RowIterationContext<T>) => R | Promise<R>, options?: RowIterationOptions): Promise<R[]>;
-/**
- * Shared row-iteration loop for filter.
+ * Row iteration for map (and forEach/filter via label).
+ * Concurrency: `parallel` | `synchronized` | `sequential` (see RowIterationOptions).
  */
+export declare function runMap<T, R>(env: TableIterationEnv<T>, callback: (ctx: RowIterationContext<T>) => R | Promise<R>, options?: RowIterationOptions, label?: string): Promise<R[]>;
+/** Filter via map; returns matched rows as {@link SmartRowArray}. */
 export declare function runFilter<T>(env: TableIterationEnv<T>, predicate: (ctx: RowIterationContext<T>) => boolean | Promise<boolean>, options?: RowIterationOptions): Promise<SmartRowArray<T>>;

package/dist/engine/tableIteration.js

@@ -14,160 +14,126 @@ exports.runMap = runMap;
 exports.runFilter = runFilter;
 const elementTracker_1 = require("../utils/elementTracker");
 const debugUtils_1 = require("../utils/debugUtils");
+const navigationBarrier_1 = require("../utils/navigationBarrier");
+const mutex_1 = require("../utils/mutex");
 function log(config, msg) {
     (0, debugUtils_1.logDebug)(config, 'verbose', msg);
 }
-/**
- * Shared row-iteration loop used by forEach, map, and filter.
- */
+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 = {}) {
-        var _a, _b, _c, _d;
-        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 parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : false;
-        const useBulk = (_d = options.useBulkPagination) !== null && _d !== void 0 ? _d : false;
-        const tracker = new elementTracker_1.ElementTracker('forEach');
-        log(env.config, `forEach: starting (maxPages=${effectiveMaxPages}, parallel=${parallel}, dedupe=${!!dedupeStrategy})`);
-        try {
-            let rowIndex = 0;
-            let stopped = false;
-            let pagesScanned = 1;
-            let totalProcessed = 0;
-            const stop = () => {
-                log(env.config, `forEach: stop() called — halting after current page`);
-                stopped = true;
-            };
-            while (!stopped) {
-                const rowLocators = env.getRowLocators();
-                const newIndices = yield tracker.getUnseenIndices(rowLocators);
-                const pageRows = yield rowLocators.all();
-                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i));
-                log(env.config, `forEach: page ${pagesScanned} — ${newIndices.length} new row(s) found`);
-                if (parallel) {
-                    yield Promise.all(smartRows.map((row) => __awaiter(this, void 0, void 0, function* () {
-                        if (stopped)
-                            return;
-                        if (dedupeKeys && dedupeStrategy) {
-                            const key = yield dedupeStrategy(row);
-                            if (dedupeKeys.has(key)) {
-                                log(env.config, `forEach: dedupe skip key="${key}"`);
-                                return;
-                            }
-                            dedupeKeys.add(key);
-                        }
-                        yield callback({ row, rowIndex: row.rowIndex, stop });
-                        totalProcessed++;
-                    })));
-                }
-                else {
-                    for (const row of smartRows) {
-                        if (stopped)
-                            break;
-                        if (dedupeKeys && dedupeStrategy) {
-                            const key = yield dedupeStrategy(row);
-                            if (dedupeKeys.has(key)) {
-                                log(env.config, `forEach: dedupe skip key="${key}"`);
-                                continue;
-                            }
-                            dedupeKeys.add(key);
-                        }
-                        yield callback({ row, rowIndex: row.rowIndex, stop });
-                        totalProcessed++;
-                    }
-                }
-                rowIndex += smartRows.length;
-                if (stopped || pagesScanned >= effectiveMaxPages)
-                    break;
-                log(env.config, `forEach: advancing to next page (${pagesScanned} → ${pagesScanned + 1})`);
-                if (!(yield env.advancePage(useBulk))) {
-                    log(env.config, `forEach: no more pages — done`);
-                    break;
-                }
-                pagesScanned++;
-            }
-            log(env.config, `forEach: complete — ${totalProcessed} row(s) processed across ${pagesScanned} page(s)`);
-        }
-        finally {
-            yield tracker.cleanup(env.getPage());
-        }
+        yield runMap(env, callback, options, 'forEach');
     });
 }
 /**
- * Shared row-iteration loop for map.
+ * 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 = {}) {
-        var _a, _b, _c, _d;
+    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 parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : true;
-        const useBulk = (_d = options.useBulkPagination) !== null && _d !== void 0 ? _d : false;
-        const tracker = new elementTracker_1.ElementTracker('map');
-        log(env.config, `map: starting (maxPages=${effectiveMaxPages}, parallel=${parallel}, dedupe=${!!dedupeStrategy})`);
+        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';
+        const useMutex = concurrency !== 'parallel';
+        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 = [];
-        const SKIP = Symbol('skip');
         try {
             let rowIndex = 0;
             let stopped = false;
+            let stoppedIndex = Infinity;
             let pagesScanned = 1;
-            const stop = () => {
-                log(env.config, `map: stop() called — halting after current page`);
-                stopped = true;
+            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 smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i));
-                log(env.config, `map: scanning page ${pagesScanned} — ${newIndices.length} new row(s)`);
-                if (parallel) {
-                    const pageResults = yield Promise.all(smartRows.map((row) => __awaiter(this, void 0, void 0, function* () {
-                        if (dedupeKeys && dedupeStrategy) {
-                            const key = yield dedupeStrategy(row);
-                            if (dedupeKeys.has(key)) {
-                                log(env.config, `map: dedupe skip key="${key}"`);
+                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) {
                                 return SKIP;
                             }
-                            dedupeKeys.add(key);
+                            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();
+                            }
+                        }
+                        finally {
+                            // Ensure the barrier is notified once per row, even on error or skip.
+                            barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
+                        }
+                    });
+                    const pageResults = [];
+                    if (concurrency === 'sequential') {
+                        for (const row of smartRows) {
+                            pageResults.push(yield processRow(row));
                         }
-                        return callback({ row, rowIndex: row.rowIndex, stop });
-                    })));
-                    for (const r of pageResults) {
-                        if (r !== SKIP)
-                            results.push(r);
                     }
-                }
-                else {
-                    for (const row of smartRows) {
-                        if (stopped)
+                    else {
+                        const results = yield Promise.all(smartRows.map(processRow));
+                        pageResults.push(...results);
+                    }
+                    for (let i = 0; i < pageResults.length; i++) {
+                        if (smartRows[i].rowIndex > stoppedIndex)
                             break;
-                        if (dedupeKeys && dedupeStrategy) {
-                            const key = yield dedupeStrategy(row);
-                            if (dedupeKeys.has(key)) {
-                                log(env.config, `map: dedupe skip key="${key}"`);
-                                continue;
-                            }
-                            dedupeKeys.add(key);
-                        }
-                        results.push(yield callback({ row, rowIndex: row.rowIndex, stop }));
+                        const r = pageResults[i];
+                        if (r !== SKIP)
+                            results.push(r);
                     }
+                    rowIndex += batchSize;
                 }
-                rowIndex += smartRows.length;
                 if (stopped || pagesScanned >= effectiveMaxPages)
                     break;
-                log(env.config, `map: advancing to next page (${pagesScanned} → ${pagesScanned + 1})`);
+                log(env.config, `${label}: advancing to next page (${pagesScanned} → ${pagesScanned + 1})`);
                 if (!(yield env.advancePage(useBulk))) {
-                    log(env.config, `map: no more pages — done`);
+                    log(env.config, `${label}: no more pages — done`);
                     break;
                 }
                 pagesScanned++;
             }
-            log(env.config, `map: complete — ${results.length} result(s) across ${pagesScanned} page(s)`);
+            log(env.config, `${label}: complete — ${results.length} result(s) across ${pagesScanned} page(s)`);
         }
         finally {
             yield tracker.cleanup(env.getPage());
@@ -175,82 +141,14 @@ function runMap(env_1, callback_1) {
         return results;
     });
 }
-/**
- * Shared row-iteration loop for filter.
- */
+/** 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 = {}) {
-        var _a, _b, _c, _d;
-        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 parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : false;
-        const useBulk = (_d = options.useBulkPagination) !== null && _d !== void 0 ? _d : false;
-        const tracker = new elementTracker_1.ElementTracker('filter');
-        log(env.config, `filter: starting (maxPages=${effectiveMaxPages}, parallel=${parallel}, dedupe=${!!dedupeStrategy})`);
-        const matched = [];
-        try {
-            let rowIndex = 0;
-            let stopped = false;
-            let pagesScanned = 1;
-            const stop = () => {
-                log(env.config, `filter: stop() called — halting after current page`);
-                stopped = true;
-            };
-            while (!stopped) {
-                const rowLocators = env.getRowLocators();
-                const newIndices = yield tracker.getUnseenIndices(rowLocators);
-                const pageRows = yield rowLocators.all();
-                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i, pagesScanned - 1));
-                log(env.config, `filter: scanning page ${pagesScanned} — ${newIndices.length} new row(s)`);
-                if (parallel) {
-                    const flags = yield Promise.all(smartRows.map((row) => __awaiter(this, void 0, void 0, function* () {
-                        if (dedupeKeys && dedupeStrategy) {
-                            const key = yield dedupeStrategy(row);
-                            if (dedupeKeys.has(key)) {
-                                log(env.config, `filter: dedupe skip key="${key}"`);
-                                return false;
-                            }
-                            dedupeKeys.add(key);
-                        }
-                        return predicate({ row, rowIndex: row.rowIndex, stop });
-                    })));
-                    smartRows.forEach((row, i) => { if (flags[i])
-                        matched.push(row); });
-                }
-                else {
-                    for (const row of smartRows) {
-                        if (stopped)
-                            break;
-                        if (dedupeKeys && dedupeStrategy) {
-                            const key = yield dedupeStrategy(row);
-                            if (dedupeKeys.has(key)) {
-                                log(env.config, `filter: dedupe skip key="${key}"`);
-                                continue;
-                            }
-                            dedupeKeys.add(key);
-                        }
-                        if (yield predicate({ row, rowIndex: row.rowIndex, stop })) {
-                            matched.push(row);
-                        }
-                    }
-                }
-                rowIndex += smartRows.length;
-                if (stopped || pagesScanned >= effectiveMaxPages)
-                    break;
-                log(env.config, `filter: advancing to next page (${pagesScanned} → ${pagesScanned + 1})`);
-                if (!(yield env.advancePage(useBulk))) {
-                    log(env.config, `filter: no more pages — done`);
-                    break;
-                }
-                pagesScanned++;
-            }
-            log(env.config, `filter: complete — ${matched.length} match(es) across ${pagesScanned} page(s)`);
-        }
-        finally {
-            yield tracker.cleanup(env.getPage());
-        }
-        return env.createSmartRowArray(matched);
+        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);
     });
 }

package/dist/engine/tableMapper.js

@@ -109,6 +109,7 @@ class TableMapper {
                         seenHeaders
                     });
                 }
+                this.log(`Header mapping index ${i}: "${text}"`);
                 entries.push([text, i]);
                 seenHeaders.add(text);
             }

package/dist/plugins/index.d.ts

@@ -12,6 +12,7 @@ export declare const Plugins: {
         rowSelector?: string | undefined;
         cellSelector?: string | ((row: import("playwright-core").Locator) => import("playwright-core").Locator) | undefined;
         maxPages?: number | undefined;
+        concurrency?: import("../types").RowIterationMode | undefined;
         headerTransformer?: ((args: {
             text: string;
             index: number;
@@ -31,6 +32,7 @@ export declare const Plugins: {
         rowSelector?: string | undefined;
         cellSelector?: string | ((row: import("playwright-core").Locator) => import("playwright-core").Locator) | undefined;
         maxPages?: number | undefined;
+        concurrency?: import("../types").RowIterationMode | undefined;
         headerTransformer?: ((args: {
             text: string;
             index: number;
@@ -50,6 +52,7 @@ export declare const Plugins: {
         rowSelector?: string | undefined;
         cellSelector?: string | ((row: import("playwright-core").Locator) => import("playwright-core").Locator) | undefined;
         maxPages?: number | undefined;
+        concurrency?: import("../types").RowIterationMode | undefined;
         headerTransformer?: ((args: {
             text: string;
             index: number;

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

@@ -8,4 +8,7 @@ export declare const glideGoUp: (context: StrategyContext) => Promise<void>;
 export declare const glideGoDown: (context: StrategyContext) => Promise<void>;
 export declare const glideGoLeft: (context: StrategyContext) => Promise<void>;
 export declare const glideGoRight: (context: StrategyContext) => Promise<void>;
-export declare const glideGoHome: (context: StrategyContext) => Promise<void>;
+/** Coarse `scrollLeft` toward `columnIndex`; `goLeft`/`goRight` correct the remainder. */
+export declare const glideSeekColumnIndex: (context: StrategyContext, columnIndex: number) => Promise<void>;
+/** `scrollLeft = 0` so low `aria-colindex` cells exist again (see smartRow for optional `Home`). */
+export declare const glideSnapFirstColumnIntoView: (context: StrategyContext) => Promise<void>;

package/dist/presets/glide/columns.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.glideGoHome = exports.glideGoRight = exports.glideGoLeft = exports.glideGoDown = exports.glideGoUp = void 0;
+exports.glideSnapFirstColumnIntoView = exports.glideSeekColumnIndex = exports.glideGoRight = exports.glideGoLeft = exports.glideGoDown = exports.glideGoUp = void 0;
 /**
  * Primitive navigation functions for Glide Data Grid.
  * These define HOW to move, not WHEN to move.
@@ -23,29 +23,40 @@ const glideGoDown = (context) => __awaiter(void 0, void 0, void 0, function* ()
     yield context.page.keyboard.press('ArrowDown');
 });
 exports.glideGoDown = glideGoDown;
+// Horizontal: use page `.dvn-scroller` (canvas root is not its ancestor). Virtualized rows expose
+// a small window of `td[aria-colindex]` that shifts with scrollLeft.
+const nudgePageScroller = (page, delta) => __awaiter(void 0, void 0, void 0, function* () {
+    const scroller = page.locator('.dvn-scroller').first();
+    yield scroller.evaluate((el, d) => {
+        el.scrollLeft += d;
+    }, delta);
+});
 const glideGoLeft = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    yield context.page.keyboard.press('ArrowLeft');
+    yield nudgePageScroller(context.page, -400);
 });
 exports.glideGoLeft = glideGoLeft;
 const glideGoRight = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    yield context.page.keyboard.press('ArrowRight');
+    yield nudgePageScroller(context.page, 400);
 });
 exports.glideGoRight = glideGoRight;
-const glideGoHome = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    const { root, page } = context;
-    // Glide renders to canvas - the accessibility table (root) is inside the canvas
-    yield root.evaluate((el) => {
-        var _a;
-        const canvas = el.closest('canvas') || ((_a = el.parentElement) === null || _a === void 0 ? void 0 : _a.querySelector('canvas'));
-        if (canvas instanceof HTMLCanvasElement) {
-            canvas.tabIndex = 0;
-            canvas.focus();
-        }
-    });
+/** Coarse `scrollLeft` toward `columnIndex`; `goLeft`/`goRight` correct the remainder. */
+const glideSeekColumnIndex = (context, columnIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    const { page } = context;
+    const scroller = page.locator('.dvn-scroller').first();
+    yield scroller.evaluate((el, colIdx) => {
+        const max = Math.max(0, el.scrollWidth - el.clientWidth);
+        const ratio = Math.min(1, Math.max(0, (colIdx + 0.5) / 64));
+        el.scrollLeft = Math.floor(ratio * max);
+    }, columnIndex);
     yield page.waitForTimeout(100);
-    yield page.keyboard.press('Control+Home');
-    yield page.keyboard.press('Meta+ArrowUp');
-    yield page.keyboard.press('Home');
+});
+exports.glideSeekColumnIndex = glideSeekColumnIndex;
+/** `scrollLeft = 0` so low `aria-colindex` cells exist again (see smartRow for optional `Home`). */
+const glideSnapFirstColumnIntoView = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    const { page } = context;
+    yield page.locator('.dvn-scroller').first().evaluate((el) => {
+        el.scrollLeft = 0;
+    });
     yield page.waitForTimeout(150);
 });
-exports.glideGoHome = glideGoHome;
+exports.glideSnapFirstColumnIntoView = glideSnapFirstColumnIntoView;

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

@@ -15,6 +15,8 @@ export declare const GlideStrategies: {
         goLeft: (context: import("../../types").StrategyContext) => Promise<void>;
         goRight: (context: import("../../types").StrategyContext) => Promise<void>;
         goHome: (context: import("../../types").StrategyContext) => Promise<void>;
+        snapFirstColumnIntoView: (context: import("../../types").StrategyContext) => Promise<void>;
+        seekColumnIndex: (context: import("../../types").StrategyContext, columnIndex: number) => Promise<void>;
     };
     loading: {
         isHeaderLoading: () => Promise<boolean>;

package/dist/presets/glide/index.js

@@ -14,7 +14,25 @@ const columns_1 = require("./columns");
 const headers_1 = require("./headers");
 const pagination_1 = require("../../strategies/pagination");
 const stabilization_1 = require("../../strategies/stabilization");
-const glideFillStrategy = (_a) => __awaiter(void 0, [_a], void 0, function* ({ value, page }) {
+const glideFillStrategy = (_a) => __awaiter(void 0, [_a], void 0, function* ({ row, columnName, value, page }) {
+    // Canvas-aware click: Glide is a canvas grid. The accessibility 'td' elements
+    // may not trigger internal focus on a simple click. We click the canvas at the cell's location.
+    const cell = row.getCell(columnName);
+    const box = yield cell.boundingBox();
+    const canvas = page.locator('canvas').first();
+    const cBox = yield canvas.boundingBox();
+    if (box && cBox) {
+        yield canvas.click({
+            position: {
+                x: box.x - cBox.x + box.width / 2,
+                y: box.y - cBox.y + box.height / 2
+            }
+        });
+    }
+    else {
+        // Fallback
+        yield cell.focus();
+    }
     yield page.keyboard.press('Enter');
     const textarea = page.locator('textarea.gdg-input');
     yield textarea.waitFor({ state: 'visible', timeout: 2000 });
@@ -50,7 +68,9 @@ const glidePaginationStrategy = pagination_1.PaginationStrategies.infiniteScroll
     timeout: 5000
 });
 const glideGetCellLocator = ({ row, columnIndex }) => {
-    return row.locator('td').nth(columnIndex);
+    // WAI-ARIA: aria-colindex is 1-based; header map index 0 → "1", index 59 → "60".
+    // Rows are virtualized: only a window of `td`s exists; navigation must scroll `.dvn-scroller`.
+    return row.locator(`td[aria-colindex="${columnIndex + 1}"]`);
 };
 const glideGetActiveCell = (_a) => __awaiter(void 0, [_a], void 0, function* ({ page }) {
     const focused = page.locator('*:focus').first();
@@ -80,7 +100,9 @@ const GlideDefaultStrategies = {
         goDown: columns_1.glideGoDown,
         goLeft: columns_1.glideGoLeft,
         goRight: columns_1.glideGoRight,
-        goHome: columns_1.glideGoHome
+        goHome: columns_1.glideSnapFirstColumnIntoView,
+        snapFirstColumnIntoView: columns_1.glideSnapFirstColumnIntoView,
+        seekColumnIndex: columns_1.glideSeekColumnIndex
     },
     loading: {
         isHeaderLoading: () => __awaiter(void 0, void 0, void 0, function* () { return false; })
@@ -99,6 +121,7 @@ const GlidePreset = {
     headerSelector: 'table[role="grid"] thead tr th',
     rowSelector: 'table[role="grid"] tbody tr',
     cellSelector: 'td',
+    concurrency: 'sequential',
     strategies: GlideDefaultStrategies
 };
 exports.Glide = Object.defineProperty(GlidePreset, 'Strategies', { get: () => exports.GlideStrategies, enumerable: false });

package/dist/smartRow.d.ts

@@ -1,5 +1,6 @@
 import type { Locator, Page } from '@playwright/test';
 import { SmartRow as SmartRowType, FinalTableConfig, TableResult } from './types';
+import { NavigationBarrier } from './utils/navigationBarrier';
 /**
  * Factory to create a SmartRow by extending a Playwright Locator.
  * We avoid Class/Proxy to ensure full compatibility with Playwright's expect(locator) matchers.
@@ -8,5 +9,5 @@ import { SmartRow as SmartRowType, FinalTableConfig, TableResult } from './types
  * @internal Internal factory for creating SmartRow objects.
  * Not part of the public package surface; tests and consumers should use public APIs.
  */
-declare const createSmartRow: <T = any>(rowLocator: Locator, map: Map<string, number>, rowIndex: number | undefined, config: FinalTableConfig<T>, rootLocator: Locator, resolve: (item: any, parent: Locator | Page) => Locator, table: TableResult<T> | null, tablePageIndex?: number) => SmartRowType<T>;
+declare const createSmartRow: <T = any>(rowLocator: Locator, map: Map<string, number>, rowIndex: number | undefined, config: FinalTableConfig<T>, rootLocator: Locator, resolve: (item: any, parent: Locator | Page) => Locator, table: TableResult<T> | null, tablePageIndex?: number, barrier?: NavigationBarrier) => SmartRowType<T>;
 export default createSmartRow;