perf(driver): ask the resolver for the candidate list once, not once per index

Deriving a locator asked "which index am I?" by calling resolve() for 1, 2, 3 …
25 — and every one of those re-scans the document (getVisibleText + isVisible +
hasMatchingDescendant over the whole candidate set). The loop only ends early
when the element WINS an index, so an element whose text repeats — a column
header standing in six list views on an enterprise screen — pays all 25 to learn
it has no wildcard identity at all.

Measured on a live PolicyCenter page (2030 nodes, ~220 candidates): ~400ms for
one such element, and ~25s for the snapshot the agent layer takes before every
state-changing action, with CDP Runtime.evaluate timeouts on top.

- resolveAll(tag, text, contains) returns exactly the candidates resolve() would
  consider, in resolve()'s own order: same predicate, same ranker seam, same
  shadow-DOM fallback. resolveAll(...)[i - 1] === resolve(..., i, ...).
- the predicate itself moves into _matchList, so the ranked path and the new one
  share one implementation of "what matches" (the unranked path keeps its own
  short-circuiting copy — it can stop at the index-th match).
- the text test now runs BEFORE isVisible in every path. isVisible ends in
  getBoundingClientRect + elementFromPoint — a layout flush and a hit test — and
  running it first spent both on every node on the page, nearly all of which
  never matched. Same result set, strictly less work.

Four e2e cases pin the contract, the equivalence one asserted inside the page so
it compares element identity rather than ids: index-for-index agreement with
resolve() (and nothing one past the list), non-candidates reported absent rather
than guessed, the ranked order honoured, and the shadow-DOM sweep.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ptrthomas

karate-core/src/main/resources/io/karatelabs/driver/driver.js

@@ -282,13 +282,16 @@
         var descendants = el.querySelectorAll(selector);
         for (var i = 0; i < descendants.length; i++) {
             var desc = descendants[i];
-            if (!this.isVisible(desc)) continue;
+            // Text BEFORE visibility, deliberately: isVisible() ends in getBoundingClientRect +
+            // elementFromPoint — a layout flush and a hit test — while getVisibleText() only reads
+            // styles. Same result set, but the expensive half now runs only for elements whose text
+            // actually matches, instead of for every node on the page. (See _matchList.)
             var descText = this.getVisibleText(desc);
             if (!descText) continue;
             var matches = contains
                 ? descText.indexOf(text) !== -1
                 : descText === text;
-            if (matches) return true;
+            if (matches && this.isVisible(desc)) return true;
         }
         return false;
     };
@@ -340,18 +343,19 @@
         var count = 0;
         for (var i = 0; i < candidates.length; i++) {
             var el = candidates[i];
-            if (!this.isVisible(el)) continue;
             if (text === '') {
+                if (!this.isVisible(el)) continue;
                 count++;
                 if (count === index) return el;
                 continue;
             }
+            // text first, then the layout-forcing visibility test — see _matchList
             var elText = this.getVisibleText(el);
             if (!elText) continue;
             var matches = contains
                 ? elText.indexOf(text) !== -1
                 : elText === text;
-            if (matches) {
+            if (matches && this.isVisible(el)) {
                 if (this.hasMatchingDescendant(el, text, contains, selector)) continue;
                 count++;
                 if (count === index) return el;
@@ -361,29 +365,74 @@
     };
 
     /**
-     * Ranked resolution path (active only when a ranker is registered).
-     * Collects ALL matches with the same predicate the default path applies,
-     * hands them to the ranker, then applies the same index selection to the
-     * ranked list \u2014 so an identity ranker reproduces default behavior exactly.
+     * The predicate itself, as a list: every candidate satisfying (tag, text),
+     * in DOM order. The unranked path above keeps its own short-circuiting copy
+     * (it can stop at the index-th match); everything that needs the WHOLE list
+     * comes through here, so there is one implementation of "what matches".
      */
-    kjs._resolveRanked = function(candidates, tag, text, index, contains, selector) {
+    kjs._matchList = function(candidates, tag, text, contains, selector) {
         var matches = [];
         for (var i = 0; i < candidates.length; i++) {
             var el = candidates[i];
-            if (!this.isVisible(el)) continue;
             if (text === '') {
-                matches.push(el);
+                if (this.isVisible(el)) matches.push(el);
                 continue;
             }
+            // Cheap test first. isVisible() forces layout (getBoundingClientRect) and hit-tests
+            // (elementFromPoint) — on a `*` resolve over an enterprise page that is thousands of
+            // layout flushes, and all but a handful are spent on elements whose text never matched.
+            // getVisibleText() reads styles only. The set is identical; the order is not.
             var elText = this.getVisibleText(el);
             if (!elText) continue;
             var ok = contains
                 ? elText.indexOf(text) !== -1
                 : elText === text;
-            if (ok && !this.hasMatchingDescendant(el, text, contains, selector)) {
+            if (ok && this.isVisible(el) && !this.hasMatchingDescendant(el, text, contains, selector)) {
                 matches.push(el);
             }
         }
+        return matches;
+    };
+
+    /**
+     * Every candidate resolve() would consider for (tag, text), in resolve()'s
+     * own order — same visibility + leaf-text predicate, same ranker seam, same
+     * shadow-DOM fallback (the deep sweep runs when the light DOM matched none).
+     *
+     * This exists for the caller that needs an element's INDEX rather than the
+     * element at an index: without it, "which index am I?" is answered by calling
+     * resolve() for 1, 2, 3 … n, and every one of those re-scans the document.
+     * On a page whose text repeats — an enterprise screen with the same column
+     * header in six list views — that walk dominates the caller's whole run.
+     * `resolveAll(tag, text, contains)[i - 1] === resolve(tag, text, i, contains)`.
+     */
+    kjs.resolveAll = function(tag, text, contains) {
+        var selector = this.getSelector(tag);
+        text = ('' + (text || '')).replace(/\s+/g, ' ').trim();
+        var matches = this._matchList(document.querySelectorAll(selector), tag, text, contains, selector);
+        if (!matches.length && this.hasShadowDOM()) {
+            matches = this._matchList(this.querySelectorAllDeep(selector), tag, text, contains, selector);
+        }
+        if (!this._resolveRanker) return matches;
+        try {
+            var ranked = this._resolveRanker(matches.slice(), {
+                tag: tag, text: text, index: 1, contains: contains, selector: selector
+            });
+            if (Array.isArray(ranked)) return ranked;
+        } catch (e) {
+            this.log('resolve ranker failed, using default order', {error: '' + e});
+        }
+        return matches;
+    };
+
+    /**
+     * Ranked resolution path (active only when a ranker is registered).
+     * Collects ALL matches with the same predicate the default path applies,
+     * hands them to the ranker, then applies the same index selection to the
+     * ranked list \u2014 so an identity ranker reproduces default behavior exactly.
+     */
+    kjs._resolveRanked = function(candidates, tag, text, index, contains, selector) {
+        var matches = this._matchList(candidates, tag, text, contains, selector);
         var ranked = matches;
         try {
             var result = this._resolveRanker(matches.slice(), {

karate-core/src/test/java/io/karatelabs/driver/e2e/LocatorsE2eTest.java

@@ -567,4 +567,64 @@ void testResolveRankerMayAddCandidatesTheDefaultFilterExcluded() {
         assertEquals("hidden-menu", driver.attribute("{div}Save", "id"));
     }
 
+    // ========== resolveAll (the candidate list behind resolve) ==========
+    // Asking "which index am I?" used to mean calling resolve() for 1, 2, 3 … n, and each of
+    // those re-scans the document — on an enterprise page whose text repeats, that walk cost
+    // hundreds of ms PER ELEMENT and dominated the caller's run. resolveAll answers it in one
+    // scan, and is only worth having if it is EXACTLY what resolve() would have said.
+
+    @Test
+    void testResolveAllIsIndexByIndexWhatResolveReturns() {
+        driver.setUrl("data:text/html,"
+                + "<b id='one'>Status</b><i>skip</i><b id='two'>Status</b>"
+                + "<b id='three'>Status</b><b id='other'>Elsewhere</b>");
+        // the equivalence, asserted in the page so it compares element IDENTITY, not ids
+        Object verdict = driver.script("(function(){"
+                + " var all = window.__kjs.resolveAll('b', 'Status', false);"
+                + " for (var i = 0; i < all.length; i++) {"
+                + "   if (all[i] !== window.__kjs.resolve('b', 'Status', i + 1, false)) return 'differs at ' + (i + 1);"
+                + " }"
+                + " if (window.__kjs.resolve('b', 'Status', all.length + 1, false)) return 'resolve saw one past the list';"
+                + " return 'ok:' + all.length; })()");
+        assertEquals("ok:3", String.valueOf(verdict));
+    }
+
+    @Test
+    void testResolveAllReportsNonCandidatesAsAbsentRatherThanGuessing() {
+        driver.setUrl("data:text/html,<b id='hit'>Status</b><b id='miss'>Other</b>");
+        Object verdict = driver.script("(function(){"
+                + " var all = window.__kjs.resolveAll('b', 'Status', false);"
+                + " return [all.length,"
+                + "  all.indexOf(document.getElementById('hit')),"
+                + "  all.indexOf(document.getElementById('miss')),"
+                + "  window.__kjs.resolveAll('b', 'NothingHere', false).length].join(','); })()");
+        assertEquals("1,0,-1,0", String.valueOf(verdict));
+    }
+
+    @Test
+    void testResolveAllHonoursTheRankerSoItStillAgreesWithResolve() {
+        driver.setUrl("data:text/html,<b id='one'>X</b><b id='two'>X</b><b id='three'>X</b>");
+        driver.script("window.__kjs.setResolveRanker(function(m){ m.push(m.shift()); return m; })");
+        Object ranked = driver.script("(function(){"
+                + " var all = window.__kjs.resolveAll('b', 'X', false);"
+                + " var ids = []; for (var i = 0; i < all.length; i++) ids.push(all[i].id);"
+                + " return ids.join(','); })()");
+        assertEquals("two,three,one", String.valueOf(ranked));
+        // …and index-for-index that is still what resolve() hands back under the same ranker
+        assertEquals("two", driver.attribute("{b:1}X", "id"));
+        assertEquals("one", driver.attribute("{b:3}X", "id"));
+    }
+
+    @Test
+    void testResolveAllFallsBackToTheDeepSweepLikeResolveDoes() {
+        driver.setUrl("data:text/html,<div id='host'></div>");
+        driver.script("(function(){ var h = document.getElementById('host').attachShadow({mode:'open'});"
+                + " h.innerHTML = \"<b id='inner'>Shadowed</b>\"; })()");
+        Object verdict = driver.script("(function(){"
+                + " var all = window.__kjs.resolveAll('b', 'Shadowed', false);"
+                + " if (all.length !== 1) return 'list length ' + all.length;"
+                + " return all[0] === window.__kjs.resolve('b', 'Shadowed', 1, false) ? 'same' : 'different'; })()");
+        assertEquals("same", String.valueOf(verdict));
+    }
+
 }