patchright-core 1.57.0 → 1.58.2

package/lib/server/frames.js

@@ -177,6 +177,9 @@ class FrameManager {
     } else {
       frame._currentDocument = { documentId, request: void 0 };
     }
+    frame._iframeWorld = void 0;
+    frame._mainWorld = void 0;
+    frame._isolatedWorld = void 0;
     frame._onClearLifecycle();
     const navigationEvent = { url, name, newDocument: frame._currentDocument, isPublic: true };
     this._fireInternalFrameNavigation(frame, navigationEvent);
@@ -352,6 +355,11 @@ class FrameManager {
     frame.emit(Frame.Events.InternalNavigation, event);
   }
 }
+const FrameEvent = {
+  InternalNavigation: "internalnavigation",
+  AddLifecycle: "addlifecycle",
+  RemoveLifecycle: "removelifecycle"
+};
 class Frame extends import_instrumentation.SdkObject {
   constructor(page, id, parentFrame) {
     super(page, "frame");
@@ -384,11 +392,7 @@ class Frame extends import_instrumentation.SdkObject {
       this._startNetworkIdleTimer();
   }
   static {
-    this.Events = {
-      InternalNavigation: "internalnavigation",
-      AddLifecycle: "addlifecycle",
-      RemoveLifecycle: "removelifecycle"
-    };
+    this.Events = FrameEvent;
   }
   isDetached() {
     return this._detachedScope.isClosed();
@@ -403,9 +407,6 @@ class Frame extends import_instrumentation.SdkObject {
     this._page.mainFrame()._recalculateNetworkIdle();
   }
   _onClearLifecycle() {
-    this._isolatedWorld = void 0;
-    this._mainWorld = void 0;
-    this._iframeWorld = void 0;
     for (const event of this._firedLifecycleEvents)
       this.emit(Frame.Events.RemoveLifecycle, event);
     this._firedLifecycleEvents.clear();
@@ -456,7 +457,11 @@ class Frame extends import_instrumentation.SdkObject {
     });
   }
   nonStallingEvaluateInExistingContext(expression, world) {
-    return this.raceAgainstEvaluationStallingEvents(() => {
+    return this.raceAgainstEvaluationStallingEvents(async () => {
+      try {
+        await this._context(world);
+      } catch {
+      }
       const context = this._contextData.get(world)?.context;
       if (!context)
         throw new Error("Frame does not yet have the execution context");
@@ -574,7 +579,7 @@ class Frame extends import_instrumentation.SdkObject {
     const request = navigationEvent.newDocument ? navigationEvent.newDocument.request : void 0;
     return request ? progress.race(request._finalRequest().response()) : null;
   }
-  async _waitForLoadState(progress, state) {
+  async waitForLoadState(progress, state) {
     const waitUntil = verifyLifecycle("state", state);
     if (!this._firedLifecycleEvents.has(waitUntil))
       await import_helper.helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e) => e === waitUntil).promise;
@@ -595,7 +600,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._sessionForFrame(this)._onExecutionContextCreated({
           id: executionContextId,
           origin: world,
           name: world,
@@ -607,13 +612,14 @@ class Frame extends import_instrumentation.SdkObject {
           serializationOptions: { serialization: "idOnly" }
         });
         if (!globalThis2) {
+          if (this.isDetached()) throw new Error("Frame was detached");
           return;
         }
         var globalThisObjId = globalThis2["result"]["objectId"];
         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._sessionForFrame(this)._onExecutionContextCreated({
           id: executionContextId,
           origin: world,
           name: world,
@@ -629,12 +635,13 @@ class Frame extends import_instrumentation.SdkObject {
         worldName: world
       });
       if (!result) {
+        if (this.isDetached()) throw new Error("Frame was detached");
         return;
       }
       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._sessionForFrame(this)._onExecutionContextCreated({
         id: executionContextId,
         origin: world,
         name: world,
@@ -643,7 +650,7 @@ class Frame extends import_instrumentation.SdkObject {
     }
     if (world != "main") {
       return this._isolatedWorld;
-    } else if (this != this._page.mainFrame() && iframeExecutionContextId) {
+    } else if (this != this._page.mainFrame() && this._iframeWorld) {
       return this._iframeWorld;
     } else {
       return this._mainWorld;
@@ -659,13 +666,13 @@ class Frame extends import_instrumentation.SdkObject {
     return this._context("utility");
   }
   async evaluateExpression(expression, options = {}, arg) {
-    const context = await this._context(options.world ?? "main");
-    const value = await context.evaluateExpression(expression, options, arg);
+    const context = await this._detachedScope.race(this._context(options.world ?? "main"));
+    const value = await this._detachedScope.race(context.evaluateExpression(expression, options, arg));
     return value;
   }
   async evaluateExpressionHandle(expression, options = {}, arg) {
-    const context = await this._context(options.world ?? "utility");
-    const value = await context.evaluateExpressionHandle(expression, options, arg);
+    const context = await this._detachedScope.race(this._context(options.world ?? "utility"));
+    const value = await this._detachedScope.race(context.evaluateExpressionHandle(expression, options, arg));
     return value;
   }
   async querySelector(selector, options) {
@@ -687,7 +694,15 @@ class Frame extends import_instrumentation.SdkObject {
       throw new Error(`state: expected one of (attached|detached|visible|hidden)`);
     if (performActionPreChecksAndLog)
       progress.log(`waiting for ${this._asLocator(selector)}${state === "attached" ? "" : " to be " + state}`);
-    const promise = this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, async (handle) => {
+    const promise = this._retryWithProgressIfNotConnected(progress, selector, { ...options, performActionPreChecks: true, __patchrightWaitForSelector: true, __patchrightInitialScope: scope }, async (handle) => {
+      if (scope) {
+        const scopeIsConnected = await scope.evaluateInUtility(([injected, node]) => node.isConnected, {}).catch(() => false);
+        if (scopeIsConnected !== true) {
+          if (state === "hidden" || state === "detached")
+            return null;
+          throw new dom.NonRecoverableDOMError("Element is not attached to the DOM");
+        }
+      }
       const attached = !!handle;
       var visible = false;
       if (attached) {
@@ -718,17 +733,55 @@ class Frame extends import_instrumentation.SdkObject {
         return "internal:continuepolling";
       }
     }, "returnOnNotResolved");
-    return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
+    const resultPromise = scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
+    return resultPromise.catch((e) => {
+      if (this.isDetached() && e?.message?.includes("Execution context was destroyed"))
+        throw new Error("Frame was detached");
+      throw e;
+    });
   }
   async dispatchEvent(progress, selector, type, eventInit = {}, options, scope) {
-    await this._callOnElementOnceMatches(progress, selector, (injectedScript, element, data) => {
+    const eventInitHandles = [];
+    const visited = /* @__PURE__ */ new WeakSet();
+    const collectHandles = (value) => {
+      if (!value || typeof value !== "object")
+        return;
+      if (value instanceof js.JSHandle) {
+        eventInitHandles.push(value);
+        return;
+      }
+      if (visited.has(value))
+        return;
+      visited.add(value);
+      if (Array.isArray(value)) {
+        for (const item of value)
+          collectHandles(item);
+        return;
+      }
+      for (const propertyValue of Object.values(value))
+        collectHandles(propertyValue);
+    };
+    collectHandles(eventInit);
+    const allHandlesFromSameFrame = eventInitHandles.length > 0 && eventInitHandles.every((handle) => handle._context?.frame === eventInitHandles[0]?._context?.frame);
+    const handlesFrame = eventInitHandles[0]?._context?.frame;
+    const canRetryInSecondaryContext = allHandlesFromSameFrame && (handlesFrame !== this || !selector.includes("internal:control=enter-frame"));
+    const callback = (injectedScript, element, data) => {
       injectedScript.dispatchEvent(element, data.type, data.eventInit);
-    }, { type, eventInit }, { mainWorld: true, ...options }, scope);
+    };
+    try {
+      await this._callOnElementOnceMatches(progress, selector, callback, { type, eventInit }, { mainWorld: true, ...options }, scope);
+    } catch (e) {
+      if ("JSHandles can be evaluated only in the context they were created!" === e.message && canRetryInSecondaryContext) {
+        await this._callOnElementOnceMatches(progress, selector, callback, { type, eventInit }, { ...options }, scope);
+        return;
+      }
+      throw e;
+    }
   }
   async evalOnSelector(selector, strict, expression, isFunction, arg, scope) {
     const handle = await this.selectors.query(selector, { strict }, scope);
     if (!handle)
-      throw new Error("Failed to find element matching selector " + selector);
+      throw new Error('Failed to find element matching selector "' + selector + '"');
     const result = await handle.evaluateExpression(expression, { isFunction }, arg, true);
     handle.dispose();
     return result;
@@ -759,7 +812,7 @@ class Frame extends import_instrumentation.SdkObject {
       metadata,
       race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
     };
-    return await this._retryWithoutProgress(progress, selector, null, false, async (result) => {
+    return await this._retryWithoutProgress(progress, selector, { strict: null, performActionPreChecks: false }, async (result) => {
       if (!result || !result[0]) return [];
       return result[1];
     }, "returnAll", null);
@@ -771,7 +824,7 @@ class Frame extends import_instrumentation.SdkObject {
       metadata,
       race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
     };
-    return await this._retryWithoutProgress(progress, selector, null, false, async (result) => {
+    return await this._retryWithoutProgress(progress, selector, { strict: null, performActionPreChecks: false }, async (result) => {
       if (!result) return 0;
       const handle = result[0];
       const handles = result[1];
@@ -801,9 +854,9 @@ class Frame extends import_instrumentation.SdkObject {
       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.waitForLoadState(progress, waitUntil).then(resolve).catch(reject);
       });
-      const setContentPromise = this._page.delegate._mainFrameSession._client.send("Page.setDocumentContent", {
+      const setContentPromise = this._page.delegate._sessionForFrame(this)._client.send("Page.setDocumentContent", {
         frameId: this._id,
         html
       });
@@ -968,26 +1021,27 @@ class Frame extends import_instrumentation.SdkObject {
       return true;
     return false;
   }
-  async _retryWithProgressIfNotConnected(progress, selector, strict, performActionPreChecks, action, returnAction) {
-    progress.log("waiting for " + this._asLocator(selector));
+  async _retryWithProgressIfNotConnected(progress, selector, options, action, returnAction) {
+    if (!options?.__patchrightSkipRetryLogWaiting)
+      progress.log("waiting for " + this._asLocator(selector));
     return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async (continuePolling) => {
-      return this._retryWithoutProgress(progress, selector, strict, performActionPreChecks, action, returnAction, continuePolling);
+      return this._retryWithoutProgress(progress, selector, options, action, returnAction, continuePolling);
     });
   }
   async rafrafTimeoutScreenshotElementWithProgress(progress, selector, timeout, options) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, true, true, async (handle) => {
+    return await this._retryWithProgressIfNotConnected(progress, selector, { strict: true, performActionPreChecks: true }, async (handle) => {
       await handle._frame.rafrafTimeout(progress, timeout);
       return await this._page.screenshotter.screenshotElement(progress, handle, 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 })));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (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)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._dblclick(progress, options)));
   }
   async dragAndDrop(progress, source, target, options) {
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force, async (handle) => {
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options, 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);
@@ -997,7 +1051,7 @@ class Frame extends import_instrumentation.SdkObject {
         position: options.sourcePosition
       });
     }));
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false, async (handle) => {
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, { ...options, performActionPreChecks: false }, async (handle) => {
       return handle._retryPointerAction(progress, "move and up", false, async (point) => {
         await this._page.mouse.move(progress, point.x, point.y, { steps: options.steps });
         await this._page.mouse.up(progress);
@@ -1011,16 +1065,16 @@ class Frame extends import_instrumentation.SdkObject {
   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.");
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._tap(progress, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (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)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (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)));
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._focus(progress)));
   }
   async blur(progress, selector, options) {
-    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._blur(progress)));
+    dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._blur(progress)));
   }
   async resolveSelector(progress, selector, options = {}) {
     const element = await progress.race(this.selectors.query(selector, options));
@@ -1131,7 +1185,7 @@ class Frame extends import_instrumentation.SdkObject {
           }, { scope });
         }
       } else {
-        return await this._retryWithoutProgress(progress2, selector, options.strict, false, async (handle) => {
+        return await this._retryWithoutProgress(progress2, selector, { ...options, performActionPreChecks: false }, async (handle) => {
           if (!handle) return false;
           if (handle.parentNode.constructor.name == "ElementHandle") {
             return await handle.parentNode.evaluateInUtility(([injected, node, { handle: handle2 }]) => {
@@ -1173,35 +1227,35 @@ class Frame extends import_instrumentation.SdkObject {
     return this._elementState(progress, selector, "checked", options, scope);
   }
   async hover(progress, selector, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force, (handle) => handle._hover(progress, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._hover(progress, 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));
+    return await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._selectOption(progress, elements, values, options));
   }
   async setInputFiles(progress, selector, params) {
     const inputFileItems = await (0, import_fileUploadUtils.prepareFilesForUpload)(this, params);
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true, (handle) => handle._setInputFiles(progress, inputFileItems)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params, (handle) => handle._setInputFiles(progress, inputFileItems)));
   }
   async type(progress, selector, text, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._type(progress, text, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._type(progress, text, options)));
   }
   async press(progress, selector, key, options) {
-    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._press(progress, key, options)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (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)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (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)));
+    return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options, (handle) => handle._setChecked(progress, false, 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()));
+    return await this._retryWithProgressIfNotConnected(progress, selector, { strict: true, performActionPreChecks: 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` : ""}`);
+  async expect(progress, selector, options) {
+    progress.log(`${(0, import_utils.renderTitleForCall)(progress.metadata)}${options.timeoutForLogs ? ` with timeout ${options.timeoutForLogs}ms` : ""}`);
     const lastIntermediateResult = { isSet: false };
     const fixupMetadataError = (result) => {
       if (result.matches === options.isNot)
@@ -1210,17 +1264,19 @@ class Frame extends import_instrumentation.SdkObject {
     try {
       if (selector)
         progress.log(`waiting for ${this._asLocator(selector)}`);
-      await this._page.performActionPreChecks(progress);
+      if (!options.noAutoWaiting)
+        await this._page.performActionPreChecks(progress);
       try {
         const resultOneShot = await this._expectInternal(progress, selector, options, lastIntermediateResult, true);
-        if (resultOneShot.matches !== options.isNot)
+        if (options.noAutoWaiting || resultOneShot.matches !== options.isNot)
           return resultOneShot;
       } catch (e) {
-        if (this.isNonRetriableError(e))
+        if (options.noAutoWaiting || this.isNonRetriableError(e))
           throw e;
       }
       const result = await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1e3], async (continuePolling) => {
-        await this._page.performActionPreChecks(progress);
+        if (!options.noAutoWaiting)
+          await this._page.performActionPreChecks(progress);
         const { matches, received } = await this._expectInternal(progress, selector, options, lastIntermediateResult, false);
         if (matches === options.isNot) {
           return continuePolling;
@@ -1250,11 +1306,17 @@ class Frame extends import_instrumentation.SdkObject {
     const isArray = options.expression === "to.have.count" || options.expression.endsWith(".array");
     var log, matches, received, missingReceived;
     if (selector) {
-      const { frame, info } = await race(this.selectors.resolveFrameForSelector(selector, { strict: true }));
+      var frame, info;
+      try {
+        var { frame, info } = await race(this.selectors.resolveFrameForSelector(selector, { strict: true }));
+      } catch (e) {
+      }
       const action = async (result) => {
         if (!result) {
           if (options.expectedNumber === 0)
             return { matches: true };
+          if (options.isNot && options.expectedNumber)
+            return { matches: false, received: 0 };
           if (!options.isNot && options.expression === "to.be.hidden")
             return { matches: true };
           if (options.isNot && options.expression === "to.be.visible")
@@ -1265,6 +1327,12 @@ class Frame extends import_instrumentation.SdkObject {
             return { matches: false };
           if (options.isNot && options.expression === "to.be.in.viewport")
             return { matches: false };
+          if (options.expression === "to.have.text.array") {
+            if (options.expectedText.length === 0)
+              return { matches: true, received: [] };
+            if (options.isNot && options.expectedText.length !== 0)
+              return { matches: false, received: [] };
+          }
           return { matches: options.isNot, missingReceived: true };
         }
         const handle = result[0];
@@ -1280,9 +1348,9 @@ class Frame extends import_instrumentation.SdkObject {
         }
       };
       if (noAbort) {
-        var { log, matches, received, missingReceived } = await this._retryWithoutProgress(progress, selector, !isArray, false, action, "returnAll", null);
+        var { log, matches, received, missingReceived } = await this._retryWithoutProgress(progress, selector, { strict: !isArray, performActionPreChecks: false }, action, "returnAll", null);
       } else {
-        var { log, matches, received, missingReceived } = await race(this._retryWithProgressIfNotConnected(progress, selector, !isArray, false, action, "returnAll"));
+        var { log, matches, received, missingReceived } = await race(this._retryWithProgressIfNotConnected(progress, selector, { strict: !isArray, performActionPreChecks: false, __patchrightSkipRetryLogWaiting: true }, action, "returnAll"));
       }
     } else {
       const world = options.expression === "to.have.property" ? "main" : "utility";
@@ -1295,10 +1363,18 @@ class Frame extends import_instrumentation.SdkObject {
     if (log)
       progress.log(log);
     if (matches === options.isNot) {
-      lastIntermediateResult.received = missingReceived ? "<element(s) not found>" : received;
+      if (missingReceived) {
+        lastIntermediateResult.errorMessage = "Error: element(s) not found";
+      } else {
+        lastIntermediateResult.errorMessage = void 0;
+        lastIntermediateResult.received = received;
+      }
       lastIntermediateResult.isSet = true;
-      if (!missingReceived && !Array.isArray(received))
-        progress.log(`  unexpected value "${renderUnexpectedValue(options.expression, received)}"`);
+      if (!missingReceived) {
+        const rendered = renderUnexpectedValue(options.expression, received);
+        if (rendered !== void 0)
+          progress.log('  unexpected value "' + rendered + '"');
+      }
     }
     return { matches, received };
   }
@@ -1354,7 +1430,7 @@ class Frame extends import_instrumentation.SdkObject {
         return { result, abort: () => aborted = true };
       }, { expression, isFunction, polling: options.pollingInterval, arg }));
       try {
-        return await progress.race(handle.evaluateHandle((h) => h.result));
+        return await progress.race(this._detachedScope.race(handle.evaluateHandle((h) => h.result)));
       } catch (error) {
         await handle.evaluate((h) => h.abort()).catch(() => {
         });
@@ -1400,6 +1476,12 @@ class Frame extends import_instrumentation.SdkObject {
         data.context.contextDestroyed("Frame was detached");
       data.contextPromise.resolve({ destroyedReason: "Frame was detached" });
     }
+    if (this._mainWorld)
+      this._mainWorld.contextDestroyed("Frame was detached");
+    if (this._iframeWorld)
+      this._iframeWorld.contextDestroyed("Frame was detached");
+    if (this._isolatedWorld)
+      this._isolatedWorld.contextDestroyed("Frame was detached");
     if (this._parentFrame)
       this._parentFrame._childFrames.delete(this);
     this._parentFrame = null;
@@ -1411,15 +1493,33 @@ class Frame extends import_instrumentation.SdkObject {
     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
-        });
+        if (options?.mainWorld) {
+          promise = (async () => {
+            const mainContext = await this._mainContext();
+            const adoptedScope = await this._page.delegate.adoptElementHandle(scope, mainContext);
+            try {
+              return await mainContext.evaluate(([injected, node, { callbackText: callbackText2, scope: handle2, taskData: taskData2 }]) => {
+                const callback = injected.eval(callbackText2);
+                return callback(injected, handle2, taskData2);
+              }, [
+                await mainContext.injectedScript(),
+                adoptedScope,
+                { callbackText, scope: adoptedScope, taskData }
+              ]);
+            } finally {
+              adoptedScope.dispose();
+            }
+          })();
+        } else {
+          promise = scopeParentNode.evaluateInUtility(([injected, node, { callbackText: callbackText2, scope: handle2, taskData: taskData2 }]) => {
+            const callback = injected.eval(callbackText2);
+            return callback(injected, handle2, taskData2);
+          }, {
+            callbackText,
+            scope,
+            taskData
+          });
+        }
       } else {
         promise = scopeParentNode.evaluate((injected, { callbackText: callbackText2, scope: handle2, taskData: taskData2 }) => {
           const callback = injected.eval(callbackText2);
@@ -1431,12 +1531,40 @@ class Frame extends import_instrumentation.SdkObject {
         });
       }
     } else {
-      promise = this._retryWithProgressIfNotConnected(progress, selector, options.strict, false, async (handle) => {
+      promise = this._retryWithProgressIfNotConnected(progress, selector, { ...options, performActionPreChecks: false }, async (handle) => {
         if (handle.parentNode.constructor.name == "ElementHandle") {
+          if (options?.mainWorld) {
+            const mainContext = await handle._frame._mainContext();
+            const adoptedHandle = await this._page.delegate.adoptElementHandle(handle, mainContext);
+            try {
+              return await mainContext.evaluate(([injected, node, { callbackText: callbackText2, handle: handle2, taskData: taskData2 }]) => {
+                const callback = injected.eval(callbackText2);
+                return callback(injected, handle2, taskData2);
+              }, [
+                await mainContext.injectedScript(),
+                adoptedHandle,
+                { callbackText, handle: adoptedHandle, taskData }
+              ]);
+            } finally {
+              adoptedHandle.dispose();
+            }
+          }
+          const [taskScope] = Object.values(taskData?.eventInit ?? {});
+          if (taskScope) {
+            const taskScopeContext = taskScope._context;
+            const adoptedHandle = await handle._adoptTo(taskScopeContext);
+            return await taskScopeContext.evaluate(([injected, node, { callbackText: callbackText2, adoptedHandle: handle2, taskData: taskData2 }]) => {
+              const callback = injected.eval(callbackText2);
+              return callback(injected, handle2, taskData2);
+            }, [
+              await taskScopeContext.injectedScript(),
+              adoptedHandle,
+              { callbackText, adoptedHandle, taskData }
+            ]);
+          }
           return await handle.parentNode.evaluateInUtility(([injected, node, { callbackText: callbackText2, handle: handle2, taskData: taskData2 }]) => {
             const callback = injected.eval(callbackText2);
-            const haha = callback(injected, handle2, taskData2);
-            return haha;
+            return callback(injected, handle2, taskData2);
           }, {
             callbackText,
             handle,
@@ -1513,21 +1641,23 @@ class Frame extends import_instrumentation.SdkObject {
         var describedNode = await client._sendMayFail("DOM.describeNode", {
           backendNodeId: globalDocument.backendNodeId
         });
-        if (describedNode) {
+        if (describedNode && describedNode.node.contentDocument) {
           var resolvedNode = await client._sendMayFail("DOM.resolveNode", {
-            nodeId: describedNode.node.contentDocument.nodeId
+            backendNodeId: describedNode.node.contentDocument.backendNodeId
           });
-          var _executionContextId = parseInt(resolvedNode.object.objectId.split(".")[1], 10);
-          return _executionContextId;
+          if (resolvedNode && resolvedNode.object && resolvedNode.object.objectId) {
+            var _executionContextId = parseInt(resolvedNode.object.objectId.split(".")[1], 10);
+            return _executionContextId;
+          }
         }
       }
     } catch (e) {
     }
     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 });
+  async _retryWithoutProgress(progress, selector, options, action, returnAction, continuePolling) {
+    if (options.performActionPreChecks) await this._page.performActionPreChecks(progress);
+    const resolved = await this.selectors.resolveInjectedForSelector(selector, { strict: options.strict }, options.__patchrightInitialScope);
     if (!resolved) {
       if (returnAction === "returnOnNotResolved" || returnAction === "returnAll") {
         const result2 = await action(null);
@@ -1550,24 +1680,51 @@ class Frame extends import_instrumentation.SdkObject {
       contextId: utilityContext.delegate._contextId
     });
     if (!documentNode) return continuePolling;
-    const documentScope = new dom.ElementHandle(utilityContext, documentNode.result.objectId);
+    let documentScope = new dom.ElementHandle(utilityContext, documentNode.result.objectId);
+    let initialScope = documentScope;
+    if (resolved.scope) {
+      const scopeBackendNodeId = resolved.scope._objectId ? (await client._sendMayFail("DOM.describeNode", { objectId: resolved.scope._objectId }))?.node?.backendNodeId : null;
+      if (scopeBackendNodeId) {
+        const scopeInUtility = await client._sendMayFail("DOM.resolveNode", { backendNodeId: scopeBackendNodeId, executionContextId: utilityContext.delegate._contextId });
+        if (scopeInUtility?.object?.objectId)
+          initialScope = new dom.ElementHandle(utilityContext, scopeInUtility.object.objectId);
+      }
+    }
+    progress.__patchrightInitialScope = resolved.scope;
+    const parsedSnapshot = options.__patchrightWaitForSelector ? JSON.parse(JSON.stringify(resolved.info.parsed)) : null;
     let currentScopingElements;
     try {
-      currentScopingElements = await this._customFindElementsByParsed(resolved, client, mainContext, documentScope, progress, resolved.info.parsed);
+      currentScopingElements = await this._customFindElementsByParsed(resolved, client, mainContext, initialScope, progress, resolved.info.parsed);
     } catch (e) {
-      if ("JSHandles can be evaluated only in the context they were created!" === e.message) return continuePolling3;
+      if ("JSHandles can be evaluated only in the context they were created!" === e.message) return continuePolling;
+      if (e instanceof TypeError && e.message.includes("is not a function")) return continuePolling;
       await progress.race(resolved.injected.evaluateHandle((injected, { error }) => {
         throw error;
       }, { error: e }));
     }
     if (currentScopingElements.length == 0) {
+      if (options.__testHookNoAutoWaiting || options.noAutoWaiting)
+        throw new dom.NonRecoverableDOMError("Element(s) not found");
+      if (parsedSnapshot && (returnAction === "returnOnNotResolved" || returnAction === "returnAll")) {
+        const elementCount = await resolved.injected.evaluate((injected, { parsed }) => {
+          return injected.querySelectorAll(parsed, document).length;
+        }, { parsed: parsedSnapshot }).catch(() => 0);
+        if (elementCount > 0)
+          return continuePolling;
+      }
       if (returnAction === "returnOnNotResolved" || returnAction === "returnAll") {
         const result2 = await action(null);
-        return result2 === "internal:continuepolling" ? continuePolling2 : result2;
+        return result2 === "internal:continuepolling" ? continuePolling : result2;
       }
       return continuePolling;
     }
     const resultElement = currentScopingElements[0];
+    await resultElement._initializePreview().catch(() => {
+    });
+    let visibilityQualifier = "";
+    if (options && options.__patchrightWaitForSelector) {
+      visibilityQualifier = await resultElement.evaluateInUtility(([injected, node]) => injected.utils.isElementVisible(node) ? "visible" : "hidden", {}).catch(() => "");
+    }
     if (currentScopingElements.length > 1) {
       if (resolved.info.strict) {
         await progress.race(resolved.injected.evaluateHandle((injected, {
@@ -1582,7 +1739,7 @@ class Frame extends import_instrumentation.SdkObject {
       }
       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());
+      progress.log("  locator resolved to " + (visibilityQualifier ? visibilityQualifier + " " : "") + resultElement.preview().replace("JSHandle@", ""));
     }
     try {
       var result = null;
@@ -1597,6 +1754,14 @@ class Frame extends import_instrumentation.SdkObject {
       } else if (result === "internal:continuepolling") {
         return continuePolling;
       }
+      if (parsedSnapshot && result === null && (options.state === "hidden" || options.state === "detached")) {
+        const visibleCount = await resolved.injected.evaluate((injected, { parsed }) => {
+          const elements = injected.querySelectorAll(parsed, document);
+          return elements.filter((e) => injected.utils.isElementVisible(e)).length;
+        }, { parsed: parsedSnapshot }).catch(() => 0);
+        if (visibleCount > 0)
+          return continuePolling;
+      }
       return result;
     } finally {
     }
@@ -1709,7 +1874,7 @@ class Frame extends import_instrumentation.SdkObject {
           }
         }
       }
-      const getParts = (pos) => (pos || "").split("").map(Number);
+      const getParts = (pos) => (pos || "").split(".").filter(Boolean).map(Number);
       elements.sort((a, b) => {
         const partA = getParts(a.nodePosition);
         const partB = getParts(b.nodePosition);