patchright-core 1.52.5 → 1.55.1

package/lib/server/frames.js

@@ -35,7 +35,6 @@ __export(frames_exports, {
 module.exports = __toCommonJS(frames_exports);
 var import_crExecutionContext = require("./chromium/crExecutionContext");
 var import_dom = require("./dom");
-var import_crypto = __toESM(require("crypto"));
 var import_browserContext = require("./browserContext");
 var dom = __toESM(require("./dom"));
 var import_errors = require("./errors");
@@ -68,8 +67,6 @@ class FrameManager {
     this._consoleMessageTags = /* @__PURE__ */ new Map();
     this._signalBarriers = /* @__PURE__ */ new Set();
     this._webSockets = /* @__PURE__ */ new Map();
-    this._openedDialogs = /* @__PURE__ */ new Set();
-    this._closeAllOpeningDialogs = false;
     this._page = page;
     this._mainFrame = void 0;
   }
@@ -124,14 +121,15 @@ class FrameManager {
       return action();
     const barrier = new SignalBarrier(progress);
     this._signalBarriers.add(barrier);
-    if (progress)
-      progress.cleanupWhenAborted(() => this._signalBarriers.delete(barrier));
-    const result = await action();
-    await this._page._delegate.inputActionEpilogue();
-    await barrier.waitFor();
-    this._signalBarriers.delete(barrier);
-    await new Promise((0, import_utils.makeWaitForNextTask)());
-    return result;
+    try {
+      const result = await action();
+      await progress.race(this._page.delegate.inputActionEpilogue());
+      await barrier.waitFor();
+      await new Promise((0, import_utils.makeWaitForNextTask)());
+      return result;
+    } finally {
+      this._signalBarriers.delete(barrier);
+    }
   }
   frameWillPotentiallyRequestNavigation() {
     for (const barrier of this._signalBarriers)
@@ -236,17 +234,8 @@ class FrameManager {
       return;
     }
     this._page.emitOnContext(import_browserContext.BrowserContext.Events.Request, request);
-    if (route) {
-      const r = new network.Route(request, route);
-      if (this._page._serverRequestInterceptor?.(r, request))
-        return;
-      if (this._page._clientRequestInterceptor?.(r, request))
-        return;
-      if (this._page._browserContext._requestInterceptor?.(r, request))
-        return;
-      r.continue({ isFallback: true }).catch(() => {
-      });
-    }
+    if (route)
+      new network.Route(request, route).handle([...this._page.requestInterceptors, ...this._page.browserContext.requestInterceptors]);
   }
   requestReceivedResponse(response) {
     if (response.request()._isFavicon)
@@ -272,26 +261,6 @@ class FrameManager {
       return;
     this._page.emitOnContext(import_browserContext.BrowserContext.Events.RequestFailed, request);
   }
-  dialogDidOpen(dialog) {
-    for (const frame of this._frames.values())
-      frame._invalidateNonStallingEvaluations("JavaScript dialog interrupted evaluation");
-    if (this._closeAllOpeningDialogs)
-      dialog.close().then(() => {
-      });
-    else
-      this._openedDialogs.add(dialog);
-  }
-  dialogWillClose(dialog) {
-    this._openedDialogs.delete(dialog);
-  }
-  async closeOpenDialogs() {
-    await Promise.all([...this._openedDialogs].map((dialog) => dialog.close())).catch(() => {
-    });
-    this._openedDialogs.clear();
-  }
-  setCloseAllOpeningDialogs(closeDialogs) {
-    this._closeAllOpeningDialogs = closeDialogs;
-  }
   removeChildFramesRecursively(frame) {
     for (const child of frame.childFrames())
       this._removeFramesRecursively(child);
@@ -459,7 +428,7 @@ class Frame extends import_instrumentation.SdkObject {
   async raceAgainstEvaluationStallingEvents(cb) {
     if (this._pendingDocument)
       throw new Error("Frame is currently attempting a navigation");
-    if (this._page._frameManager._openedDialogs.size)
+    if (this._page.browserContext.dialogManager.hasOpenDialogsForPage(this._page))
       throw new Error("Open JavaScript dialog prevents evaluation");
     const promise = new import_manualPromise.ManualPromise();
     this._raceAgainstEvaluationStallingEventsPromises.add(promise);
@@ -506,7 +475,7 @@ class Frame extends import_instrumentation.SdkObject {
       this.emit(Frame.Events.RemoveLifecycle, "networkidle");
     }
   }
-  async raceNavigationAction(progress, options, action) {
+  async raceNavigationAction(progress, action) {
     return import_utils.LongStandingScope.raceMultiple([
       this._detachedScope,
       this._page.openScope
@@ -515,30 +484,26 @@ class Frame extends import_instrumentation.SdkObject {
         const data = this._redirectedNavigations.get(e.documentId);
         if (data) {
           progress.log(`waiting for redirected navigation to "${data.url}"`);
-          return data.gotoPromise;
+          return progress.race(data.gotoPromise);
         }
       }
       throw e;
     }));
   }
   redirectNavigation(url, documentId, referer) {
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this);
+    const controller = new import_progress.ProgressController();
     const data = {
       url,
-      gotoPromise: controller.run((progress) => this._gotoAction(progress, url, { referer }), 0)
+      gotoPromise: controller.run((progress) => this.gotoImpl(progress, url, { referer }), 0)
     };
     this._redirectedNavigations.set(documentId, data);
     data.gotoPromise.finally(() => this._redirectedNavigations.delete(documentId));
   }
-  async goto(metadata, url, options = {}) {
-    const constructedNavigationURL = (0, import_utils.constructURLBasedOnBaseURL)(this._page._browserContext._options.baseURL, url);
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run((progress) => this._goto(progress, constructedNavigationURL, options), this._page._timeoutSettings.navigationTimeout(options));
-  }
-  async _goto(progress, url, options) {
-    return this.raceNavigationAction(progress, options, async () => this._gotoAction(progress, url, options));
+  async goto(progress, url, options = {}) {
+    const constructedNavigationURL = (0, import_utils.constructURLBasedOnBaseURL)(this._page.browserContext._options.baseURL, url);
+    return this.raceNavigationAction(progress, async () => this.gotoImpl(progress, constructedNavigationURL, options));
   }
-  async _gotoAction(progress, url, options) {
+  async gotoImpl(progress, url, options) {
     const waitUntil = verifyLifecycle("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
     progress.log(`navigating to "${url}", waiting until "${waitUntil}"`);
     const headers = this._page.extraHTTPHeaders() || [];
@@ -553,7 +518,7 @@ class Frame extends import_instrumentation.SdkObject {
     const navigationEvents = [];
     const collectNavigations = (arg) => navigationEvents.push(arg);
     this.on(Frame.Events.InternalNavigation, collectNavigations);
-    const navigateResult = await this._page._delegate.navigateFrame(this, url, referer).finally(
+    const navigateResult = await progress.race(this._page.delegate.navigateFrame(this, url, referer)).finally(
       () => this.off(Frame.Events.InternalNavigation, collectNavigations)
     );
     let event;
@@ -582,7 +547,7 @@ class Frame extends import_instrumentation.SdkObject {
     if (!this._firedLifecycleEvents.has(waitUntil))
       await import_helper.helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e) => e === waitUntil).promise;
     const request = event.newDocument ? event.newDocument.request : void 0;
-    const response = request ? request._finalRequest().response() : null;
+    const response = request ? progress.race(request._finalRequest().response()) : null;
     return response;
   }
   async _waitForNavigation(progress, requiresNewDocument, options) {
@@ -601,7 +566,7 @@ class Frame extends import_instrumentation.SdkObject {
     if (!this._firedLifecycleEvents.has(waitUntil))
       await import_helper.helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e) => e === waitUntil).promise;
     const request = navigationEvent.newDocument ? navigationEvent.newDocument.request : void 0;
-    return request ? request._finalRequest().response() : null;
+    return request ? progress.race(request._finalRequest().response()) : null;
   }
   async _waitForLoadState(progress, state) {
     const waitUntil = verifyLifecycle("state", state);
@@ -609,14 +574,14 @@ class Frame extends import_instrumentation.SdkObject {
       await import_helper.helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e) => e === waitUntil).promise;
   }
   async frameElement() {
-    return this._page._delegate.getFrameElement(this);
+    return this._page.delegate.getFrameElement(this);
   }
   async _context(world) {
     if (this.isDetached()) throw new Error("Frame was detached");
     try {
-      var client = this._page._delegate._sessionForFrame(this)._client;
+      var client = this._page.delegate._sessionForFrame(this)._client;
     } catch (e) {
-      var client = this._page._delegate._mainFrameSession._client;
+      var client = this._page.delegate._mainFrameSession._client;
     }
     var iframeExecutionContextId = await this._getFrameMainFrameContextId(client);
     if (world == "main") {
@@ -624,7 +589,7 @@ class Frame extends import_instrumentation.SdkObject {
         var executionContextId = iframeExecutionContextId;
         var crContext = new import_crExecutionContext.CRExecutionContext(client, { id: executionContextId }, this._id);
         this._iframeWorld = new import_dom.FrameExecutionContext(crContext, this, world);
-        this._page._delegate._mainFrameSession._onExecutionContextCreated({
+        this._page.delegate._mainFrameSession._onExecutionContextCreated({
           id: executionContextId,
           origin: world,
           name: world,
@@ -642,7 +607,7 @@ class Frame extends import_instrumentation.SdkObject {
         var executionContextId = parseInt(globalThisObjId.split(".")[1], 10);
         var crContext = new import_crExecutionContext.CRExecutionContext(client, { id: executionContextId }, this._id);
         this._mainWorld = new import_dom.FrameExecutionContext(crContext, this, world);
-        this._page._delegate._mainFrameSession._onExecutionContextCreated({
+        this._page.delegate._mainFrameSession._onExecutionContextCreated({
           id: executionContextId,
           origin: world,
           name: world,
@@ -663,7 +628,7 @@ class Frame extends import_instrumentation.SdkObject {
       var executionContextId = result.executionContextId;
       var crContext = new import_crExecutionContext.CRExecutionContext(client, { id: executionContextId }, this._id);
       this._isolatedWorld = new import_dom.FrameExecutionContext(crContext, this, world);
-      this._page._delegate._mainFrameSession._onExecutionContextCreated({
+      this._page.delegate._mainFrameSession._onExecutionContextCreated({
         id: executionContextId,
         origin: world,
         name: world,
@@ -693,16 +658,20 @@ class Frame extends import_instrumentation.SdkObject {
     return value;
   }
   async evaluateExpressionHandle(expression, options = {}, arg) {
-    const context = await this._context(options.world ?? "main");
+    const context = await this._context(options.world ?? "utility");
     const value = await context.evaluateExpressionHandle(expression, options, arg);
     return value;
   }
   async querySelector(selector, options) {
-    import_debugLogger.debugLogger.log("api", `    finding element using the selector "${selector}"`);
-    return this.selectors.query(selector, options);
+    return this.querySelectorAll(selector, options).then((handles) => {
+      if (handles.length === 0)
+        return null;
+      if (handles.length > 1 && options?.strict)
+        throw new Error(`Strict mode: expected one element matching selector "${selector}", found ${handles.length}`);
+      return handles[0];
+    });
   }
-  async waitForSelector(metadata, selector, options, scope) {
-    const controller = new import_progress.ProgressController(metadata, this);
+  async waitForSelector(progress, selector, performActionPreChecksAndLog, options, scope) {
     if (options.visibility)
       throw new Error("options.visibility is not supported, did you mean options.state?");
     if (options.waitFor && options.waitFor !== "visible")
@@ -710,15 +679,8 @@ class Frame extends import_instrumentation.SdkObject {
     const { state = "visible" } = options;
     if (!["attached", "detached", "visible", "hidden"].includes(state))
       throw new Error(`state: expected one of (attached|detached|visible|hidden)`);
-    return controller.run(async (progress) => {
+    if (performActionPreChecksAndLog)
       progress.log(`waiting for ${this._asLocator(selector)}${state === "attached" ? "" : " to be " + state}`);
-      return await this.waitForSelectorInternal(progress, selector, true, options, scope);
-    }, this._page._timeoutSettings.timeout(options));
-  }
-  async waitForSelectorInternal(progress, selector, performActionPreChecks, options, scope) {
-    const {
-      state = "visible"
-    } = options;
     const promise = this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, async (handle) => {
       const attached = !!handle;
       var visible = false;
@@ -726,15 +688,11 @@ class Frame extends import_instrumentation.SdkObject {
         if (handle.parentNode.constructor.name == "ElementHandle") {
           visible = await handle.parentNode.evaluateInUtility(([injected, node, { handle: handle2 }]) => {
             return handle2 ? injected.utils.isElementVisible(handle2) : false;
-          }, {
-            handle
-          });
+          }, { handle });
         } else {
           visible = await handle.parentNode.evaluate((injected, { handle: handle2 }) => {
             return handle2 ? injected.utils.isElementVisible(handle2) : false;
-          }, {
-            handle
-          });
+          }, { handle });
         }
       }
       const success = {
@@ -743,12 +701,8 @@ class Frame extends import_instrumentation.SdkObject {
         visible,
         hidden: !visible
       }[state];
-      if (!success) {
-        return "internal:continuepolling";
-      }
-      if (options.omitReturnValue) {
-        return null;
-      }
+      if (!success) return "internal:continuepolling";
+      if (options.omitReturnValue) return null;
       const element = state === "attached" || state === "visible" ? handle : null;
       if (!element) return null;
       if (options.__testHookBeforeAdoptNode) await options.__testHookBeforeAdoptNode();
@@ -760,8 +714,8 @@ class Frame extends import_instrumentation.SdkObject {
     }, "returnOnNotResolved");
     return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
   }
-  async dispatchEvent(metadata, selector, type, eventInit = {}, options = {}, scope) {
-    await this._callOnElementOnceMatches(metadata, selector, (injectedScript, element, data) => {
+  async dispatchEvent(progress, selector, type, eventInit = {}, options, scope) {
+    await this._callOnElementOnceMatches(progress, selector, (injectedScript, element, data) => {
       injectedScript.dispatchEvent(element, data.type, data.eventInit);
     }, { type, eventInit }, { mainWorld: true, ...options }, scope);
   }
@@ -775,6 +729,7 @@ class Frame extends import_instrumentation.SdkObject {
   }
   async evalOnSelectorAll(selector, expression, isFunction, arg, scope, isolatedContext) {
     try {
+      isolatedContext = this.selectors._parseSelector(selector, { strict: false }).world !== "main" && isolatedContext;
       const arrayHandle = await this.selectors.queryArrayInMainWorld(selector, scope, isolatedContext);
       const result = await arrayHandle.evaluateExpression(expression, { isFunction }, arg, isolatedContext);
       arrayHandle.dispose();
@@ -792,26 +747,30 @@ class Frame extends import_instrumentation.SdkObject {
     }, { parsed: selectors, color });
   }
   async querySelectorAll(selector) {
-    return this.selectors.queryAll(selector);
-  }
-  async queryCount(selector) {
-    const customMetadata = {
-      "internal": false,
-      "log": [],
-      "method": "queryCount"
+    const metadata = { internal: false, log: [], method: "querySelectorAll" };
+    const progress = {
+      log: (message) => metadata.log.push(message),
+      metadata,
+      race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
     };
-    const controller = new import_progress.ProgressController(customMetadata, this);
-    const resultPromise = await controller.run(async (progress) => {
-      progress.log("waiting for " + this._asLocator(selector));
-      const promise = await this._retryWithProgressIfNotConnected(progress, selector, null, false, async (result) => {
-        if (!result) return 0;
-        const handle = result[0];
-        const handles = result[1];
-        return handle ? handles.length : 0;
-      }, "returnAll");
-      return promise;
-    }, 1e4);
-    return resultPromise ? resultPromise : 0;
+    return await this._retryWithoutProgress(progress, selector, null, false, async (result) => {
+      if (!result || !result[0]) return [];
+      return result[1];
+    }, "returnAll", null);
+  }
+  async queryCount(selector, options) {
+    const metadata = { internal: false, log: [], method: "queryCount" };
+    const progress = {
+      log: (message) => metadata.log.push(message),
+      metadata,
+      race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
+    };
+    return await this._retryWithoutProgress(progress, selector, null, false, async (result) => {
+      if (!result) return 0;
+      const handle = result[0];
+      const handles = result[1];
+      return handle ? handles.length : 0;
+    }, "returnAll", null);
   }
   async content() {
     try {
@@ -825,44 +784,26 @@ class Frame extends import_instrumentation.SdkObject {
         return retVal;
       });
     } catch (e) {
-      if (js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
+      if (this.isNonRetriableError(e))
         throw e;
       throw new Error(`Unable to retrieve content because the page is navigating and changing the content.`);
     }
   }
-  async setContent(metadata, html, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      await this.raceNavigationAction(progress, options, async () => {
-        const waitUntil = options.waitUntil === void 0 ? "load" : options.waitUntil;
-        progress.log(`setting frame content, waiting until "${waitUntil}"`);
-        const tag = `--playwright--set--content--${this._id}--${++this._setContentCounter}--`;
-        const bindingName = "_tagDebug" + import_crypto.default.randomBytes(20).toString("hex");
-        const context = await this._utilityContext();
-        await this._page._delegate._mainFrameSession._client.send("Runtime.addBinding", { name: bindingName });
-        const lifecyclePromise = new Promise(async (resolve, reject) => {
-          await this._page.exposeBinding(bindingName, false, (tag2) => {
-            this._onClearLifecycle();
-            this._waitForLoadState(progress, waitUntil).then(resolve).catch(reject);
-          });
-        });
-        const contentPromise = context.evaluate(({ html: html2, tag: tag2, bindingName: bindingName2 }) => {
-          document.open();
-          var _tagDebug = window[bindingName2].bind({});
-          delete window[bindingName2];
-          _tagDebug('{ "name": "' + bindingName2 + '", "seq": 1, "serializedArgs": ["' + tag2 + '"] }');
-          console.debug(tag2);
-          document.write(html2);
-          document.close();
-        }, {
-          html,
-          tag,
-          bindingName
-        });
-        await Promise.all([contentPromise, lifecyclePromise]);
-        return null;
+  async setContent(progress, html, options) {
+    await this.raceNavigationAction(progress, async () => {
+      const waitUntil = options.waitUntil === void 0 ? "load" : options.waitUntil;
+      progress.log(`setting frame content, waiting until "${waitUntil}"`);
+      const lifecyclePromise = new Promise((resolve, reject) => {
+        this._onClearLifecycle();
+        this._waitForLoadState(progress, waitUntil).then(resolve).catch(reject);
       });
-    }, this._page._timeoutSettings.navigationTimeout(options));
+      const setContentPromise = this._page.delegate._mainFrameSession._client.send("Page.setDocumentContent", {
+        frameId: this._id,
+        html
+      });
+      await Promise.all([setContentPromise, lifecyclePromise]);
+      return null;
+    });
   }
   name() {
     return this._name || "";
@@ -894,7 +835,7 @@ class Frame extends import_instrumentation.SdkObject {
       if (url !== null)
         return (await context.evaluateHandle(addScriptUrl, { url, type })).asElement();
       const result = (await context.evaluateHandle(addScriptContent, { content, type })).asElement();
-      if (this._page._delegate.cspErrorsAsynchronousForInlineScripts)
+      if (this._page.delegate.cspErrorsAsynchronousForInlineScripts)
         await context.evaluate(() => true);
       return result;
     });
@@ -968,7 +909,7 @@ class Frame extends import_instrumentation.SdkObject {
     let cspMessage;
     const actionPromise = func().then((r) => result = r).catch((e) => error = e);
     const errorPromise = new Promise((resolve) => {
-      listeners.push(import_eventsHelper.eventsHelper.addEventListener(this._page._browserContext, import_browserContext.BrowserContext.Events.Console, (message) => {
+      listeners.push(import_eventsHelper.eventsHelper.addEventListener(this._page.browserContext, import_browserContext.BrowserContext.Events.Console, (message) => {
         if (message.page() !== this._page || message.type() !== "error")
           return;
         if (message.text().includes("Content-Security-Policy") || message.text().includes("Content Security Policy")) {
@@ -989,31 +930,30 @@ class Frame extends import_instrumentation.SdkObject {
     const continuePolling = Symbol("continuePolling");
     timeouts = [0, ...timeouts];
     let timeoutIndex = 0;
-    while (progress.isRunning()) {
+    while (true) {
       const timeout = timeouts[Math.min(timeoutIndex++, timeouts.length - 1)];
       if (timeout) {
         const actionPromise = new Promise((f) => setTimeout(f, timeout));
-        await import_utils.LongStandingScope.raceMultiple([
+        await progress.race(import_utils.LongStandingScope.raceMultiple([
           this._page.openScope,
           this._detachedScope
-        ], actionPromise);
+        ], actionPromise));
       }
-      progress.throwIfAborted();
       try {
         const result = await action(continuePolling);
         if (result === continuePolling)
           continue;
         return result;
       } catch (e) {
-        if (this._isErrorThatCannotBeRetried(e))
+        if (this.isNonRetriableError(e))
           throw e;
         continue;
       }
     }
-    progress.throwIfAborted();
-    return void 0;
   }
-  _isErrorThatCannotBeRetried(e) {
+  isNonRetriableError(e) {
+    if ((0, import_progress.isAbortError)(e))
+      return true;
     if (js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
       return true;
     if (dom.isNonRecoverableDOMError(e) || (0, import_selectorParser.isInvalidSelectorError)(e))
@@ -1025,186 +965,115 @@ class Frame extends import_instrumentation.SdkObject {
   async _retryWithProgressIfNotConnected(progress, selector, strict, performActionPreChecks, action, returnAction) {
     progress.log("waiting for " + this._asLocator(selector));
     return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async (continuePolling) => {
-      if (performActionPreChecks) await this._page.performActionPreChecks(progress);
-      const resolved = await this.selectors.resolveInjectedForSelector(selector, {
-        strict
-      });
-      progress.throwIfAborted();
-      if (!resolved) {
-        if (returnAction === "returnOnNotResolved" || returnAction === "returnAll") {
-          const result2 = await action(null);
-          return result2 === "internal:continuepolling" ? continuePolling2 : result2;
-        }
-        return continuePolling;
-      }
-      try {
-        var client = this._page._delegate._sessionForFrame(resolved.frame)._client;
-      } catch (e) {
-        var client = this._page._delegate._mainFrameSession._client;
-      }
-      var utilityContext = await resolved.frame._utilityContext();
-      var mainContext = await resolved.frame._mainContext();
-      const documentNode = await client.send("Runtime.evaluate", {
-        expression: "document",
-        serializationOptions: {
-          serialization: "idOnly"
-        },
-        contextId: utilityContext.delegate._contextId
-      });
-      const documentScope = new dom.ElementHandle(utilityContext, documentNode.result.objectId);
-      let currentScopingElements;
-      try {
-        currentScopingElements = await this._customFindElementsByParsed(resolved, client, mainContext, documentScope, progress, resolved.info.parsed);
-      } catch (e) {
-        if ("JSHandles can be evaluated only in the context they were created!" === e.message) return continuePolling3;
-        await resolved.injected.evaluateHandle((injected, { error }) => {
-          throw error;
-        }, { error: e });
-      }
-      if (currentScopingElements.length == 0) {
-        if (returnAction === "returnOnNotResolved" || returnAction === "returnAll") {
-          const result2 = await action(null);
-          return result2 === "internal:continuepolling" ? continuePolling2 : result2;
-        }
-        return continuePolling;
-      }
-      const resultElement = currentScopingElements[0];
-      if (currentScopingElements.length > 1) {
-        if (resolved.info.strict) {
-          await resolved.injected.evaluateHandle((injected, {
-            info,
-            elements
-          }) => {
-            throw injected.strictModeViolationError(info.parsed, elements);
-          }, {
-            info: resolved.info,
-            elements: currentScopingElements
-          });
-        }
-        progress.log("  locator resolved to " + currentScopingElements.length + " elements. Proceeding with the first one: " + resultElement.preview());
-      } else if (resultElement) {
-        progress.log("  locator resolved to " + resultElement.preview());
-      }
-      try {
-        var result = null;
-        if (returnAction === "returnAll") {
-          result = await action([resultElement, currentScopingElements]);
-        } else {
-          result = await action(resultElement);
-        }
-        if (result === "error:notconnected") {
-          progress.log("element was detached from the DOM, retrying");
-          return continuePolling;
-        } else if (result === "internal:continuepolling") {
-          return continuePolling;
-        }
-        return result;
-      } finally {
-      }
+      return this._retryWithoutProgress(progress, selector, strict, performActionPreChecks, action, returnAction, continuePolling);
     });
   }
   async rafrafTimeoutScreenshotElementWithProgress(progress, selector, timeout, options) {
     return await this._retryWithProgressIfNotConnected(progress, selector, true, true, async (handle) => {
-      await handle._frame.rafrafTimeout(timeout);
-      return await this._page._screenshotter.screenshotElement(progress, handle, options);
+      await handle._frame.rafrafTimeout(progress, timeout);
+      return await this._page.screenshotter.screenshotElement(progress, handle, options);
     });
   }
-  async click(metadata, selector, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._click(progress, { ...options, waitAfter: !options.noWaitAfter })));
-    }, this._page._timeoutSettings.timeout(options));
-  }
-  async dblclick(metadata, selector, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._dblclick(progress, options)));
-    }, this._page._timeoutSettings.timeout(options));
-  }
-  async dragAndDrop(metadata, source, target, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    await controller.run(async (progress) => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force, async (handle) => {
-        return handle._retryPointerAction(progress, "move and down", false, async (point) => {
-          await this._page.mouse.move(point.x, point.y);
-          await this._page.mouse.down();
-        }, {
-          ...options,
-          waitAfter: "disabled",
-          position: options.sourcePosition,
-          timeout: progress.timeUntilDeadline()
-        });
-      }));
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false, async (handle) => {
-        return handle._retryPointerAction(progress, "move and up", false, async (point) => {
-          await this._page.mouse.move(point.x, point.y);
-          await this._page.mouse.up();
-        }, {
-          ...options,
-          waitAfter: "disabled",
-          position: options.targetPosition,
-          timeout: progress.timeUntilDeadline()
-        });
-      }));
-    }, this._page._timeoutSettings.timeout(options));
+  async click(progress, selector, options) {
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._click(progress, { ...options, waitAfter: !options.noWaitAfter })));
+  }
+  async dblclick(progress, selector, options) {
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._dblclick(progress, options)));
+  }
+  async dragAndDrop(progress, source, target, options) {
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force, async (handle) => {
+      return handle._retryPointerAction(progress, "move and down", false, async (point) => {
+        await this._page.mouse.move(progress, point.x, point.y);
+        await this._page.mouse.down(progress);
+      }, {
+        ...options,
+        waitAfter: "disabled",
+        position: options.sourcePosition
+      });
+    }));
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false, async (handle) => {
+      return handle._retryPointerAction(progress, "move and up", false, async (point) => {
+        await this._page.mouse.move(progress, point.x, point.y);
+        await this._page.mouse.up(progress);
+      }, {
+        ...options,
+        waitAfter: "disabled",
+        position: options.targetPosition
+      });
+    }));
   }
-  async tap(metadata, selector, options) {
-    if (!this._page._browserContext._options.hasTouch)
+  async tap(progress, selector, options) {
+    if (!this._page.browserContext._options.hasTouch)
       throw new Error("The page does not support tap. Use hasTouch context option to enable touch support.");
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._tap(progress, options)));
-    }, this._page._timeoutSettings.timeout(options));
-  }
-  async fill(metadata, selector, value, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._fill(progress, value, options)));
-    }, this._page._timeoutSettings.timeout(options));
-  }
-  async focus(metadata, selector, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    await controller.run(async (progress) => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._focus(progress)));
-    }, this._page._timeoutSettings.timeout(options));
-  }
-  async blur(metadata, selector, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    await controller.run(async (progress) => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._blur(progress)));
-    }, this._page._timeoutSettings.timeout(options));
-  }
-  async textContent(metadata, selector, options = {}, scope) {
-    return this._callOnElementOnceMatches(metadata, selector, (injected, element) => element.textContent, void 0, options, scope);
-  }
-  async innerText(metadata, selector, options = {}, scope) {
-    return this._callOnElementOnceMatches(metadata, selector, (injectedScript, element) => {
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._tap(progress, options)));
+  }
+  async fill(progress, selector, value, options) {
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._fill(progress, value, options)));
+  }
+  async focus(progress, selector, options) {
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._focus(progress)));
+  }
+  async blur(progress, selector, options) {
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._blur(progress)));
+  }
+  async resolveSelector(progress, selector, options = {}) {
+    const element = await progress.race(this.selectors.query(selector, options));
+    if (!element)
+      throw new Error(`No element matching ${selector}`);
+    const generated = await progress.race(element.evaluateInUtility(async ([injected, node]) => {
+      return injected.generateSelectorSimple(node);
+    }, {}));
+    if (!generated)
+      throw new Error(`Unable to generate locator for ${selector}`);
+    let frame = element._frame;
+    const result = [generated];
+    while (frame?.parentFrame()) {
+      const frameElement = await progress.race(frame.frameElement());
+      if (frameElement) {
+        const generated2 = await progress.race(frameElement.evaluateInUtility(async ([injected, node]) => {
+          return injected.generateSelectorSimple(node);
+        }, {}));
+        frameElement.dispose();
+        if (generated2 === "error:notconnected" || !generated2)
+          throw new Error(`Unable to generate locator for ${selector}`);
+        result.push(generated2);
+      }
+      frame = frame.parentFrame();
+    }
+    const resolvedSelector = result.reverse().join(" >> internal:control=enter-frame >> ");
+    return { resolvedSelector };
+  }
+  async textContent(progress, selector, options, scope) {
+    return this._callOnElementOnceMatches(progress, selector, (injected, element) => element.textContent, void 0, options, scope);
+  }
+  async innerText(progress, selector, options, scope) {
+    return this._callOnElementOnceMatches(progress, selector, (injectedScript, element) => {
       if (element.namespaceURI !== "http://www.w3.org/1999/xhtml")
         throw injectedScript.createStacklessError("Node is not an HTMLElement");
       return element.innerText;
     }, void 0, options, scope);
   }
-  async innerHTML(metadata, selector, options = {}, scope) {
-    return this._callOnElementOnceMatches(metadata, selector, (injected, element) => element.innerHTML, void 0, options, scope);
+  async innerHTML(progress, selector, options, scope) {
+    return this._callOnElementOnceMatches(progress, selector, (injected, element) => element.innerHTML, void 0, options, scope);
   }
-  async getAttribute(metadata, selector, name, options = {}, scope) {
-    return this._callOnElementOnceMatches(metadata, selector, (injected, element, data) => element.getAttribute(data.name), { name }, options, scope);
+  async getAttribute(progress, selector, name, options, scope) {
+    return this._callOnElementOnceMatches(progress, selector, (injected, element, data) => element.getAttribute(data.name), { name }, options, scope);
   }
-  async inputValue(metadata, selector, options = {}, scope) {
-    return this._callOnElementOnceMatches(metadata, selector, (injectedScript, node) => {
+  async inputValue(progress, selector, options, scope) {
+    return this._callOnElementOnceMatches(progress, selector, (injectedScript, node) => {
       const element = injectedScript.retarget(node, "follow-label");
       if (!element || element.nodeName !== "INPUT" && element.nodeName !== "TEXTAREA" && element.nodeName !== "SELECT")
         throw injectedScript.createStacklessError("Node is not an <input>, <textarea> or <select> element");
       return element.value;
     }, void 0, options, scope);
   }
-  async highlight(selector) {
-    const resolved = await this.selectors.resolveInjectedForSelector(selector);
+  async highlight(progress, selector) {
+    const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector));
     if (!resolved)
       return;
-    return await resolved.injected.evaluate((injected, { info }) => {
+    return await progress.race(resolved.injected.evaluate((injected, { info }) => {
       return injected.highlight(info.parsed);
-    }, { info: resolved.info });
+    }, { info: resolved.info }));
   }
   async hideHighlight() {
     return this.raceAgainstEvaluationStallingEvents(async () => {
@@ -1215,28 +1084,48 @@ class Frame extends import_instrumentation.SdkObject {
       });
     });
   }
-  async _elementState(metadata, selector, state, options = {}, scope) {
-    const result = await this._callOnElementOnceMatches(metadata, selector, (injected, element, data) => {
+  async _elementState(progress, selector, state, options, scope) {
+    const result = await this._callOnElementOnceMatches(progress, selector, (injected, element, data) => {
       return injected.elementState(element, data.state);
     }, { state }, options, scope);
     if (result.received === "error:notconnected")
       dom.throwElementIsNotAttached();
     return result.matches;
   }
-  async isVisible(metadata, selector, options = {}, scope) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      progress.log(`  checking visibility of ${this._asLocator(selector)}`);
-      return await this.isVisibleInternal(selector, options, scope);
-    }, this._page._timeoutSettings.timeout({}));
+  async isVisible(progress, selector, options = {}, scope) {
+    progress.log(`  checking visibility of ${this._asLocator(selector)}`);
+    return await this.isVisibleInternal(progress, selector, options, scope);
   }
-  async isVisibleInternal(selector, options = {}, scope) {
+  async isVisibleInternal(progress, selector, options = {}, scope) {
     try {
-      const customMetadata = { "internal": false, "log": [], "method": "isVisible" };
-      const controller = new import_progress.ProgressController(customMetadata, this);
-      return await controller.run(async (progress) => {
-        progress.log("waiting for " + this._asLocator(selector));
-        const promise = this._retryWithProgressIfNotConnected(progress, selector, options.strict, false, async (handle) => {
+      const metadata = { internal: false, log: [], method: "isVisible" };
+      const progress2 = {
+        log: (message) => metadata.log.push(message),
+        metadata,
+        race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
+      };
+      progress2.log("waiting for " + this._asLocator(selector));
+      if (selector === ":scope") {
+        const scopeParentNode = scope.parentNode || scope;
+        if (scopeParentNode.constructor.name == "ElementHandle") {
+          return await scopeParentNode.evaluateInUtility(([injected, node, { scope: handle2 }]) => {
+            const state = handle2 ? injected.elementState(handle2, "visible") : {
+              matches: false,
+              received: "error:notconnected"
+            };
+            return state.matches;
+          }, { scope });
+        } else {
+          return await scopeParentNode.evaluate((injected, node, { scope: handle2 }) => {
+            const state = handle2 ? injected.elementState(handle2, "visible") : {
+              matches: false,
+              received: "error:notconnected"
+            };
+            return state.matches;
+          }, { scope });
+        }
+      } else {
+        return await this._retryWithoutProgress(progress2, selector, options.strict, false, async (handle) => {
           if (!handle) return false;
           if (handle.parentNode.constructor.name == "ElementHandle") {
             return await handle.parentNode.evaluateInUtility(([injected, node, { handle: handle2 }]) => {
@@ -1255,242 +1144,215 @@ class Frame extends import_instrumentation.SdkObject {
               return state.matches;
             }, { handle });
           }
-        }, "returnOnNotResolved");
-        return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
-      }, 1e4) || false;
+        }, "returnOnNotResolved", null);
+      }
     } catch (e) {
-      if (js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e) || (0, import_protocolError.isSessionClosedError)(e)) throw e;
+      if (this.isNonRetriableError(e)) throw e;
       return false;
     }
   }
-  async isHidden(metadata, selector, options = {}, scope) {
-    return !await this.isVisible(metadata, selector, options, scope);
+  async isHidden(progress, selector, options = {}, scope) {
+    return !await this.isVisible(progress, selector, options, scope);
   }
-  async isDisabled(metadata, selector, options = {}, scope) {
-    return this._elementState(metadata, selector, "disabled", options, scope);
+  async isDisabled(progress, selector, options, scope) {
+    return this._elementState(progress, selector, "disabled", options, scope);
   }
-  async isEnabled(metadata, selector, options = {}, scope) {
-    return this._elementState(metadata, selector, "enabled", options, scope);
+  async isEnabled(progress, selector, options, scope) {
+    return this._elementState(progress, selector, "enabled", options, scope);
   }
-  async isEditable(metadata, selector, options = {}, scope) {
-    return this._elementState(metadata, selector, "editable", options, scope);
+  async isEditable(progress, selector, options, scope) {
+    return this._elementState(progress, selector, "editable", options, scope);
   }
-  async isChecked(metadata, selector, options = {}, scope) {
-    return this._elementState(metadata, selector, "checked", options, scope);
+  async isChecked(progress, selector, options, scope) {
+    return this._elementState(progress, selector, "checked", options, scope);
   }
-  async hover(metadata, selector, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._hover(progress, options)));
-    }, this._page._timeoutSettings.timeout(options));
+  async hover(progress, selector, options) {
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._hover(progress, options)));
   }
-  async selectOption(metadata, selector, elements, values, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._selectOption(progress, elements, values, options));
-    }, this._page._timeoutSettings.timeout(options));
+  async selectOption(progress, selector, elements, values, options) {
+    return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._selectOption(progress, elements, values, options));
   }
-  async setInputFiles(metadata, selector, params) {
+  async setInputFiles(progress, selector, params) {
     const inputFileItems = await (0, import_fileUploadUtils.prepareFilesForUpload)(this, params);
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true, (handle) => handle._setInputFiles(progress, inputFileItems)));
-    }, this._page._timeoutSettings.timeout(params));
-  }
-  async type(metadata, selector, text, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._type(progress, text, options)));
-    }, this._page._timeoutSettings.timeout(options));
-  }
-  async press(metadata, selector, key, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._press(progress, key, options)));
-    }, this._page._timeoutSettings.timeout(options));
-  }
-  async check(metadata, selector, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._setChecked(progress, true, options)));
-    }, this._page._timeoutSettings.timeout(options));
-  }
-  async uncheck(metadata, selector, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._setChecked(progress, false, options)));
-    }, this._page._timeoutSettings.timeout(options));
-  }
-  async waitForTimeout(metadata, timeout) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async () => {
-      await new Promise((resolve) => setTimeout(resolve, timeout));
-    });
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true, (handle) => handle._setInputFiles(progress, inputFileItems)));
   }
-  async ariaSnapshot(metadata, selector, options = {}) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      return await this._retryWithProgressIfNotConnected(progress, selector, true, true, (handle) => handle.ariaSnapshot(options));
-    }, this._page._timeoutSettings.timeout(options));
+  async type(progress, selector, text, options) {
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._type(progress, text, options)));
   }
-  async expect(metadata, selector, options) {
-    const result = await this._expectImpl(metadata, selector, options);
-    if (result.matches === options.isNot)
-      metadata.error = { error: { name: "Expect", message: "Expect failed" } };
-    return result;
+  async press(progress, selector, key, options) {
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._press(progress, key, options)));
+  }
+  async check(progress, selector, options) {
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._setChecked(progress, true, options)));
+  }
+  async uncheck(progress, selector, options) {
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._setChecked(progress, false, options)));
   }
-  async _expectImpl(metadata, selector, options) {
+  async waitForTimeout(progress, timeout) {
+    return progress.wait(timeout);
+  }
+  async ariaSnapshot(progress, selector) {
+    return await this._retryWithProgressIfNotConnected(progress, selector, true, true, (handle) => progress.race(handle.ariaSnapshot()));
+  }
+  async expect(progress, selector, options, timeout) {
+    progress.log(`${(0, import_utils.renderTitleForCall)(progress.metadata)}${timeout ? ` with timeout ${timeout}ms` : ""}`);
     const lastIntermediateResult = { isSet: false };
+    const fixupMetadataError = (result) => {
+      if (result.matches === options.isNot)
+        progress.metadata.error = { error: { name: "Expect", message: "Expect failed" } };
+    };
     try {
-      let timeout = this._page._timeoutSettings.timeout(options);
-      const start = timeout > 0 ? (0, import_utils.monotonicTime)() : 0;
-      await new import_progress.ProgressController(metadata, this).run(async (progress) => {
-        progress.log(`${metadata.apiName}${timeout ? ` with timeout ${timeout}ms` : ""}`);
+      if (selector)
         progress.log(`waiting for ${this._asLocator(selector)}`);
-        await this._page.performActionPreChecks(progress);
-      }, timeout);
+      await this._page.performActionPreChecks(progress);
       try {
-        const resultOneShot = await new import_progress.ProgressController(metadata, this).run(async (progress) => {
-          return await this._expectInternal(progress, selector, options, lastIntermediateResult);
-        });
+        const resultOneShot = await this._expectInternal(progress, selector, options, lastIntermediateResult, true);
         if (resultOneShot.matches !== options.isNot)
           return resultOneShot;
       } catch (e) {
-        if (js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e))
+        if (this.isNonRetriableError(e))
           throw e;
       }
-      if (timeout > 0) {
-        const elapsed = (0, import_utils.monotonicTime)() - start;
-        timeout -= elapsed;
-      }
-      if (timeout < 0)
-        return { matches: options.isNot, log: (0, import_callLog.compressCallLog)(metadata.log), timedOut: true, received: lastIntermediateResult.received };
-      return await new import_progress.ProgressController(metadata, this).run(async (progress) => {
-        return await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1e3], async (continuePolling) => {
-          await this._page.performActionPreChecks(progress);
-          const { matches, received } = await this._expectInternal(progress, selector, options, lastIntermediateResult);
-          if (matches === options.isNot) {
-            return continuePolling;
-          }
-          return { matches, received };
-        });
-      }, timeout);
+      const result = await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1e3], async (continuePolling) => {
+        await this._page.performActionPreChecks(progress);
+        const { matches, received } = await this._expectInternal(progress, selector, options, lastIntermediateResult, false);
+        if (matches === options.isNot) {
+          return continuePolling;
+        }
+        return { matches, received };
+      });
+      fixupMetadataError(result);
+      return result;
     } catch (e) {
       if (js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e))
         throw e;
-      const result = { matches: options.isNot, log: (0, import_callLog.compressCallLog)(metadata.log) };
+      const result = { matches: options.isNot, log: (0, import_callLog.compressCallLog)(progress.metadata.log) };
       if (lastIntermediateResult.isSet)
         result.received = lastIntermediateResult.received;
       if (e instanceof import_errors.TimeoutError)
         result.timedOut = true;
+      fixupMetadataError(result);
       return result;
     }
   }
-  async _expectInternal(progress, selector, options, lastIntermediateResult) {
-    progress.log("waiting for " + this._asLocator(selector));
+  async _expectInternal(progress, selector, options, lastIntermediateResult, noAbort) {
+    const race = (p) => noAbort ? p : progress.race(p);
     const isArray = options.expression === "to.have.count" || options.expression.endsWith(".array");
-    const promise = await this._retryWithProgressIfNotConnected(progress, selector, !isArray, false, async (result) => {
-      if (!result) {
-        if (options.expectedNumber === 0)
-          return { matches: true };
-        if (!options.isNot && options.expression === "to.be.hidden")
-          return { matches: true };
-        if (options.isNot && options.expression === "to.be.visible")
-          return { matches: false };
-        if (!options.isNot && options.expression === "to.be.detached")
-          return { matches: true };
-        if (options.isNot && options.expression === "to.be.attached")
-          return { matches: false };
-        if (options.isNot && options.expression === "to.be.in.viewport")
-          return { matches: false };
-        return { matches: options.isNot, missingReceived: true };
-      }
-      const handle = result[0];
-      const handles = result[1];
-      if (handle.parentNode.constructor.name == "ElementHandle") {
-        return await handle.parentNode.evaluateInUtility(async ([injected, node, { handle: handle2, options: options2, handles: handles2 }]) => {
-          return await injected.expect(handle2, options2, handles2);
-        }, { handle, options, handles });
+    var log, matches, received, missingReceived;
+    if (selector) {
+      const { frame, info } = await race(this.selectors.resolveFrameForSelector(selector, { strict: true }));
+      const action = async (result) => {
+        if (!result) {
+          if (options.expectedNumber === 0)
+            return { matches: true };
+          if (!options.isNot && options.expression === "to.be.hidden")
+            return { matches: true };
+          if (options.isNot && options.expression === "to.be.visible")
+            return { matches: false };
+          if (!options.isNot && options.expression === "to.be.detached")
+            return { matches: true };
+          if (options.isNot && options.expression === "to.be.attached")
+            return { matches: false };
+          if (options.isNot && options.expression === "to.be.in.viewport")
+            return { matches: false };
+          return { matches: options.isNot, missingReceived: true };
+        }
+        const handle = result[0];
+        const handles = result[1];
+        if (handle.parentNode.constructor.name == "ElementHandle") {
+          return await handle.parentNode.evaluateInUtility(async ([injected, node, { handle: handle2, options: options2, handles: handles2 }]) => {
+            return await injected.expect(handle2, options2, handles2);
+          }, { handle, options, handles });
+        } else {
+          return await handle.parentNode.evaluate(async (injected, { handle: handle2, options: options2, handles: handles2 }) => {
+            return await injected.expect(handle2, options2, handles2);
+          }, { handle, options, handles });
+        }
+      };
+      if (noAbort) {
+        var { log, matches, received, missingReceived } = await this._retryWithoutProgress(progress, selector, !isArray, false, action, "returnAll", null);
       } else {
-        return await handle.parentNode.evaluate(async (injected, { handle: handle2, options: options2, handles: handles2 }) => {
-          return await injected.expect(handle2, options2, handles2);
-        }, { handle, options, handles });
+        var { log, matches, received, missingReceived } = await race(this._retryWithProgressIfNotConnected(progress, selector, !isArray, false, action, "returnAll"));
       }
-    }, "returnAll");
-    var matches = false;
-    var received = 0;
-    var missingReceived = null;
-    if (promise) {
-      matches = promise.matches;
-      received = promise.received;
-      missingReceived = promise.missingReceived;
-    } else if (options.expectedNumber === 0) {
-      matches = true;
+    } else {
+      const world = options.expression === "to.have.property" ? "main" : "utility";
+      const context = await race(this._context(world));
+      const injected = await race(context.injectedScript());
+      var { matches, received, missingReceived } = await race(injected.evaluate(async (injected2, { options: options2, callId }) => {
+        return { ...await injected2.expect(void 0, options2, []) };
+      }, { options, callId: progress.metadata.id }));
     }
+    if (log)
+      progress.log(log);
     if (matches === options.isNot) {
       lastIntermediateResult.received = missingReceived ? "<element(s) not found>" : received;
       lastIntermediateResult.isSet = true;
-      if (!missingReceived && !Array.isArray(received)) progress.log('  unexpected value "' + renderUnexpectedValue(options.expression, received) + '"');
+      if (!missingReceived && !Array.isArray(received))
+        progress.log(`  unexpected value "${renderUnexpectedValue(options.expression, received)}"`);
     }
-    return {
-      matches,
-      received
-    };
+    return { matches, received };
   }
-  async _waitForFunctionExpression(metadata, expression, isFunction, arg, options, world = "main") {
-    const controller = new import_progress.ProgressController(metadata, this);
+  async waitForFunctionExpression(progress, expression, isFunction, arg, options, world = "main") {
     if (typeof options.pollingInterval === "number")
       (0, import_utils.assert)(options.pollingInterval > 0, "Cannot poll with non-positive interval: " + options.pollingInterval);
     expression = js.normalizeEvaluationExpression(expression, isFunction);
-    return controller.run(async (progress) => {
-      return this.retryWithProgressAndTimeouts(progress, [100], async () => {
-        const context = world === "main" ? await this._mainContext() : await this._utilityContext();
-        const injectedScript = await context.injectedScript();
-        const handle = await injectedScript.evaluateHandle((injected, { expression: expression2, isFunction: isFunction2, polling, arg: arg2 }) => {
-          const predicate = () => {
-            let result2 = globalThis.eval(expression2);
-            if (isFunction2 === true) {
+    return this.retryWithProgressAndTimeouts(progress, [100], async () => {
+      const context = world === "main" ? await progress.race(this._mainContext()) : await progress.race(this._utilityContext());
+      const injectedScript = await progress.race(context.injectedScript());
+      const handle = await progress.race(injectedScript.evaluateHandle((injected, { expression: expression2, isFunction: isFunction2, polling, arg: arg2 }) => {
+        let evaledExpression;
+        const predicate = () => {
+          let result2 = evaledExpression ?? globalThis.eval(expression2);
+          if (isFunction2 === true) {
+            evaledExpression = result2;
+            result2 = result2(arg2);
+          } else if (isFunction2 === false) {
+            result2 = result2;
+          } else {
+            if (typeof result2 === "function") {
+              evaledExpression = result2;
               result2 = result2(arg2);
-            } else if (isFunction2 === false) {
-              result2 = result2;
-            } else {
-              if (typeof result2 === "function")
-                result2 = result2(arg2);
             }
-            return result2;
-          };
-          let fulfill;
-          let reject;
-          let aborted = false;
-          const result = new Promise((f, r) => {
-            fulfill = f;
-            reject = r;
-          });
-          const next = () => {
-            if (aborted)
+          }
+          return result2;
+        };
+        let fulfill;
+        let reject;
+        let aborted = false;
+        const result = new Promise((f, r) => {
+          fulfill = f;
+          reject = r;
+        });
+        const next = () => {
+          if (aborted)
+            return;
+          try {
+            const success = predicate();
+            if (success) {
+              fulfill(success);
               return;
-            try {
-              const success = predicate();
-              if (success) {
-                fulfill(success);
-                return;
-              }
-              if (typeof polling !== "number")
-                injected.utils.builtins.requestAnimationFrame(next);
-              else
-                injected.utils.builtins.setTimeout(next, polling);
-            } catch (e) {
-              reject(e);
             }
-          };
-          next();
-          return { result, abort: () => aborted = true };
-        }, { expression, isFunction, polling: options.pollingInterval, arg });
-        progress.cleanupWhenAborted(() => handle.evaluate((h) => h.abort()).catch(() => {
-        }));
-        return handle.evaluateHandle((h) => h.result);
-      });
-    }, this._page._timeoutSettings.timeout(options));
+            if (typeof polling !== "number")
+              injected.utils.builtins.requestAnimationFrame(next);
+            else
+              injected.utils.builtins.setTimeout(next, polling);
+          } catch (e) {
+            reject(e);
+          }
+        };
+        next();
+        return { result, abort: () => aborted = true };
+      }, { expression, isFunction, polling: options.pollingInterval, arg }));
+      try {
+        return await progress.race(handle.evaluateHandle((h) => h.result));
+      } catch (error) {
+        await handle.evaluate((h) => h.abort()).catch(() => {
+        });
+        throw error;
+      } finally {
+        handle.dispose();
+      }
+    });
   }
   async waitForFunctionValueInUtility(progress, pageFunction) {
     const expression = `() => {
@@ -1499,25 +1361,25 @@ class Frame extends import_instrumentation.SdkObject {
         return result;
       return JSON.stringify(result);
     }`;
-    const handle = await this._waitForFunctionExpression((0, import_instrumentation.serverSideCallMetadata)(), expression, true, void 0, { timeout: progress.timeUntilDeadline() }, "utility");
+    const handle = await this.waitForFunctionExpression(progress, expression, true, void 0, {}, "utility");
     return JSON.parse(handle.rawValue());
   }
   async title() {
     const context = await this._utilityContext();
     return context.evaluate(() => document.title);
   }
-  async rafrafTimeout(timeout) {
+  async rafrafTimeout(progress, timeout) {
     if (timeout === 0)
       return;
-    const context = await this._utilityContext();
+    const context = await progress.race(this._utilityContext());
     await Promise.all([
       // wait for double raf
-      context.evaluate(() => new Promise((x) => {
+      progress.race(context.evaluate(() => new Promise((x) => {
         requestAnimationFrame(() => {
           requestAnimationFrame(x);
         });
-      })),
-      new Promise((fulfill) => setTimeout(fulfill, timeout))
+      }))),
+      progress.wait(timeout)
     ]);
   }
   _onDetached() {
@@ -1532,16 +1394,39 @@ class Frame extends import_instrumentation.SdkObject {
       this._parentFrame._childFrames.delete(this);
     this._parentFrame = null;
   }
-  async _callOnElementOnceMatches(metadata, selector, body, taskData, options = {}, scope) {
+  async _callOnElementOnceMatches(progress, selector, body, taskData, options, scope) {
     const callbackText = body.toString();
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run(async (progress) => {
-      progress.log("waiting for " + this._asLocator(selector));
-      const promise = this._retryWithProgressIfNotConnected(progress, selector, options.strict, false, async (handle) => {
+    progress.log("waiting for " + this._asLocator(selector));
+    var promise;
+    if (selector === ":scope") {
+      const scopeParentNode = scope.parentNode || scope;
+      if (scopeParentNode.constructor.name == "ElementHandle") {
+        promise = scopeParentNode.evaluateInUtility(([injected, node, { callbackText: callbackText2, scope: handle2, taskData: taskData2 }]) => {
+          const callback = injected.eval(callbackText2);
+          const haha = callback(injected, handle2, taskData2);
+          return haha;
+        }, {
+          callbackText,
+          scope,
+          taskData
+        });
+      } else {
+        promise = scopeParentNode.evaluate((injected, { callbackText: callbackText2, scope: handle2, taskData: taskData2 }) => {
+          const callback = injected.eval(callbackText2);
+          return callback(injected, handle2, taskData2);
+        }, {
+          callbackText,
+          scope,
+          taskData
+        });
+      }
+    } else {
+      promise = this._retryWithProgressIfNotConnected(progress, selector, options.strict, false, async (handle) => {
         if (handle.parentNode.constructor.name == "ElementHandle") {
           return await handle.parentNode.evaluateInUtility(([injected, node, { callbackText: callbackText2, handle: handle2, taskData: taskData2 }]) => {
             const callback = injected.eval(callbackText2);
-            return callback(injected, handle2, taskData2);
+            const haha = callback(injected, handle2, taskData2);
+            return haha;
           }, {
             callbackText,
             handle,
@@ -1558,8 +1443,8 @@ class Frame extends import_instrumentation.SdkObject {
           });
         }
       });
-      return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
-    }, this._page._timeoutSettings.timeout(options));
+    }
+    return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
   }
   _setContext(world, context) {
     const data = this._contextData.get(world);
@@ -1604,35 +1489,12 @@ class Frame extends import_instrumentation.SdkObject {
   async extendInjectedScript(source, arg) {
     const context = await this._context("main");
     const injectedScriptHandle = await context.injectedScript();
-    return injectedScriptHandle.evaluateHandle((injectedScript, { source: source2, arg: arg2 }) => {
-      return injectedScript.extend(source2, arg2);
+    await injectedScriptHandle.evaluate((injectedScript, { source: source2, arg: arg2 }) => {
+      injectedScript.extend(source2, arg2);
     }, { source, arg });
   }
-  async resetStorageForCurrentOriginBestEffort(newStorage) {
-    const context = await this._utilityContext();
-    await context.evaluate(async ({ ls }) => {
-      sessionStorage.clear();
-      localStorage.clear();
-      for (const entry of ls || [])
-        localStorage[entry.name] = entry.value;
-      const registrations = navigator.serviceWorker ? await navigator.serviceWorker.getRegistrations() : [];
-      await Promise.all(registrations.map(async (r) => {
-        if (!r.installing && !r.waiting && !r.active)
-          r.unregister().catch(() => {
-          });
-        else
-          await r.unregister().catch(() => {
-          });
-      }));
-      for (const db of await indexedDB.databases?.() || []) {
-        if (db.name)
-          indexedDB.deleteDatabase(db.name);
-      }
-    }, { ls: newStorage?.localStorage }).catch(() => {
-    });
-  }
   _asLocator(selector) {
-    return (0, import_utils.asLocator)(this._page.attribution.playwright.options.sdkLanguage, selector);
+    return (0, import_utils.asLocator)(this._page.browserContext._browser.sdkLanguage(), selector);
   }
   async _getFrameMainFrameContextId(client) {
     try {
@@ -1653,6 +1515,82 @@ class Frame extends import_instrumentation.SdkObject {
     }
     return 0;
   }
+  async _retryWithoutProgress(progress, selector, strict, performActionPreChecks, action, returnAction, continuePolling) {
+    if (performActionPreChecks) await this._page.performActionPreChecks(progress);
+    const resolved = await this.selectors.resolveInjectedForSelector(selector, { strict });
+    if (!resolved) {
+      if (returnAction === "returnOnNotResolved" || returnAction === "returnAll") {
+        const result2 = await action(null);
+        return result2 === "internal:continuepolling" ? continuePolling : result2;
+      }
+      return continuePolling;
+    }
+    try {
+      var client = this._page.delegate._sessionForFrame(resolved.frame)._client;
+    } catch (e) {
+      var client = this._page.delegate._mainFrameSession._client;
+    }
+    var utilityContext = await resolved.frame._utilityContext();
+    var mainContext = await resolved.frame._mainContext();
+    const documentNode = await client._sendMayFail("Runtime.evaluate", {
+      expression: "document",
+      serializationOptions: {
+        serialization: "idOnly"
+      },
+      contextId: utilityContext.delegate._contextId
+    });
+    if (!documentNode) return continuePolling;
+    const documentScope = new dom.ElementHandle(utilityContext, documentNode.result.objectId);
+    let currentScopingElements;
+    try {
+      currentScopingElements = await this._customFindElementsByParsed(resolved, client, mainContext, documentScope, progress, resolved.info.parsed);
+    } catch (e) {
+      if ("JSHandles can be evaluated only in the context they were created!" === e.message) return continuePolling3;
+      await progress.race(resolved.injected.evaluateHandle((injected, { error }) => {
+        throw error;
+      }, { error: e }));
+    }
+    if (currentScopingElements.length == 0) {
+      if (returnAction === "returnOnNotResolved" || returnAction === "returnAll") {
+        const result2 = await action(null);
+        return result2 === "internal:continuepolling" ? continuePolling2 : result2;
+      }
+      return continuePolling;
+    }
+    const resultElement = currentScopingElements[0];
+    if (currentScopingElements.length > 1) {
+      if (resolved.info.strict) {
+        await progress.race(resolved.injected.evaluateHandle((injected, {
+          info,
+          elements
+        }) => {
+          throw injected.strictModeViolationError(info.parsed, elements);
+        }, {
+          info: resolved.info,
+          elements: currentScopingElements
+        }));
+      }
+      progress.log("  locator resolved to " + currentScopingElements.length + " elements. Proceeding with the first one: " + resultElement.preview());
+    } else if (resultElement) {
+      progress.log("  locator resolved to " + resultElement.preview());
+    }
+    try {
+      var result = null;
+      if (returnAction === "returnAll") {
+        result = await action([resultElement, currentScopingElements]);
+      } else {
+        result = await action(resultElement);
+      }
+      if (result === "error:notconnected") {
+        progress.log("element was detached from the DOM, retrying");
+        return continuePolling;
+      } else if (result === "internal:continuepolling") {
+        return continuePolling;
+      }
+      return result;
+    } finally {
+    }
+  }
   async _customFindElementsByParsed(resolved, client, context, documentScope, progress, parsed) {
     var parsedEdits = { ...parsed };
     var currentScopingElements = [documentScope];
@@ -1663,6 +1601,7 @@ class Frame extends import_instrumentation.SdkObject {
       var elementsIndexes = [];
       if (part.name == "nth") {
         const partNth = Number(part.body);
+        if (currentScopingElements.length == 0) return [];
         if (partNth > currentScopingElements.length - 1 || partNth < -(currentScopingElements.length - 1)) {
           throw new Error("Can't query n-th element");
         } else {
@@ -1784,26 +1723,27 @@ class SignalBarrier {
   }
   waitFor() {
     this.release();
-    return this._promise;
+    return this._progress.race(this._promise);
   }
-  async addFrameNavigation(frame) {
+  addFrameNavigation(frame) {
     if (frame.parentFrame())
       return;
     this.retain();
-    const waiter = import_helper.helper.waitForEvent(null, frame, Frame.Events.InternalNavigation, (e) => {
+    const waiter = import_helper.helper.waitForEvent(this._progress, frame, Frame.Events.InternalNavigation, (e) => {
       if (!e.isPublic)
         return false;
       if (!e.error && this._progress)
         this._progress.log(`  navigated to "${frame._url}"`);
       return true;
     });
-    await import_utils.LongStandingScope.raceMultiple([
+    import_utils.LongStandingScope.raceMultiple([
       frame._page.openScope,
       frame._detachedScope
     ], waiter.promise).catch(() => {
+    }).finally(() => {
+      waiter.dispose();
+      this.release();
     });
-    waiter.dispose();
-    this.release();
   }
   retain() {
     ++this._protectCount;