phantomwright-driver-core 1.58.2 → 1.58.3

package/lib/client/browserContext.js

@@ -120,11 +120,11 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
         hasListeners = page.emit(import_events.Events.Page.Dialog, dialogObject) || hasListeners;
       if (!hasListeners) {
         if (dialogObject.type() === "beforeunload")
-          dialog.accept({}).catch(() => {
-          });
+          dialogObject._wrapApiCall(() => dialog.accept({}).catch(() => {
+          }), { internal: true });
         else
-          dialog.dismiss().catch(() => {
-          });
+          dialogObject._wrapApiCall(() => dialog.dismiss().catch(() => {
+          }), { internal: true });
       }
     });
     this._channel.on("request", ({ request, page }) => this._onRequest(network.Request.from(request), import_page.Page.fromNullable(page)));
@@ -527,6 +527,7 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
         await route.fallback();
       }
     });
+    this.routeInjecting = true;
   }
 }
 async function prepareStorageState(platform, storageState) {

package/lib/client/frame.js

@@ -162,7 +162,15 @@ class Frame extends import_channelOwner.ChannelOwner {
   async waitForURL(url, options = {}) {
     if ((0, import_urlMatch.urlMatches)(this._page?.context()._options.baseURL, this.url(), url))
       return await this.waitForLoadState(options.waitUntil, options);
-    await this.waitForNavigation({ url, ...options });
+    try {
+      await this.waitForNavigation({ url, ...options });
+    } catch (error) {
+      if ((0, import_urlMatch.urlMatches)(this._page?.context()._options.baseURL, this.url(), url)) {
+        await this.waitForLoadState(options.waitUntil, options);
+        return;
+      }
+      throw error;
+    }
   }
   async frameElement() {
     return import_elementHandle.ElementHandle.from((await this._channel.frameElement()).element);

package/lib/client/locator.js

@@ -99,6 +99,10 @@ class Locator {
     });
   }
   async evaluate(pageFunction, arg, options, isolatedContext = true) {
+    if (typeof options === "boolean") {
+      isolatedContext = options;
+      options = void 0;
+    }
     return await this._withElement(
       async (h) => (0, import_jsHandle.parseResult)(
         (await h._channel.evaluateExpression({
@@ -118,6 +122,10 @@ class Locator {
     return await this._frame.$$eval(this._selector, pageFunction, arg, isolatedContext);
   }
   async evaluateHandle(pageFunction, arg, options, isolatedContext = true) {
+    if (typeof options === "boolean") {
+      isolatedContext = options;
+      options = void 0;
+    }
     return await this._withElement(
       async (h) => import_jsHandle.JSHandle.from(
         (await h._channel.evaluateExpressionHandle({

package/lib/client/network.js

@@ -128,7 +128,11 @@ class Request extends import_channelOwner.ChannelOwner {
     return await this._actualHeadersPromise;
   }
   async allHeaders() {
-    return (await this._actualHeaders()).headers();
+    const headers = await this._actualHeaders();
+    const page = this._safePage();
+    if (page?._closeWasCalled)
+      throw new import_errors.TargetClosedError();
+    return headers.headers();
   }
   async headersArray() {
     return (await this._actualHeaders()).headersArray();

package/lib/client/page.js

@@ -721,6 +721,7 @@ class Page extends import_channelOwner.ChannelOwner {
         await route.fallback();
       }
     });
+    this.routeInjecting = true;
   }
 }
 class BindingCall extends import_channelOwner.ChannelOwner {

package/lib/client/tracing.js

@@ -34,7 +34,7 @@ class Tracing extends import_channelOwner.ChannelOwner {
     return channel._object;
   }
   async start(options = {}) {
-    await this._parent.installInjectRoute();
+    if (typeof this._parent.installInjectRoute === "function") await this._parent.installInjectRoute();
     await this._wrapApiCall(async () => {
       this._includeSources = !!options.sources;
       this._isLive = !!options._live;

package/lib/server/chromium/chromium.js

@@ -277,7 +277,6 @@ class Chromium extends import_browserType.BrowserType {
     if (args.find((arg) => !arg.startsWith("-")))
       throw new Error("Arguments can not specify page to be opened");
     const chromeArguments = [...(0, import_chromiumSwitches.chromiumSwitches)(options.assistantMode, options.channel)];
-    chromeArguments.push("--enable-unsafe-swiftshader");
     if (options.headless) {
       chromeArguments.push("--headless");
       chromeArguments.push(

package/lib/server/chromium/crCoverage.js

@@ -66,6 +66,7 @@ class JSCoverage {
     this._eventListeners = [
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Debugger.scriptParsed", this._onScriptParsed.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextsCleared", this._onExecutionContextsCleared.bind(this)),
+      import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.frameNavigated", this._onFrameNavigated.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Debugger.paused", this._onDebuggerPaused.bind(this))
     ];
     await Promise.all([
@@ -117,6 +118,11 @@ class JSCoverage {
     }
     return coverage;
   }
+  _onFrameNavigated(event) {
+    if (event.frame.parentId)
+      return;
+    this._onExecutionContextsCleared();
+  }
 }
 class CSSCoverage {
   constructor(client) {
@@ -136,7 +142,8 @@ class CSSCoverage {
     this._stylesheetSources.clear();
     this._eventListeners = [
       import_eventsHelper.eventsHelper.addEventListener(this._client, "CSS.styleSheetAdded", this._onStyleSheet.bind(this)),
-      import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextsCleared", this._onExecutionContextsCleared.bind(this))
+      import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextsCleared", this._onExecutionContextsCleared.bind(this)),
+      import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.frameNavigated", this._onFrameNavigated.bind(this))
     ];
     await Promise.all([
       this._client.send("DOM.enable"),
@@ -192,6 +199,11 @@ class CSSCoverage {
     }
     return coverage;
   }
+  _onFrameNavigated(event) {
+    if (event.frame.parentId)
+      return;
+    this._onExecutionContextsCleared();
+  }
 }
 function convertToDisjointRanges(nestedRanges) {
   const points = [];

package/lib/server/chromium/crNetworkManager.js

@@ -141,6 +141,8 @@ class CRNetworkManager {
   async setRequestInterception(value) {
     this._userRequestInterceptionEnabled = value;
     await this._updateProtocolRequestInterception();
+    if (this._page)
+      await this._forEachSession((info) => info.session.send("Network.setCacheDisabled", { cacheDisabled: this._page.needsRequestInterception() }));
   }
   async _updateProtocolRequestInterception() {
     const enabled = this._userRequestInterceptionEnabled || !!this._credentials;
@@ -153,7 +155,9 @@ class CRNetworkManager {
     const enabled = this._protocolRequestInterceptionEnabled;
     if (initial && !enabled)
       return;
-    const cachePromise = info.session.send("Network.setCacheDisabled", { cacheDisabled: false });
+    const hasHarRecorders = !!this._page?.browserContext?._harRecorders?.size;
+    const userInterception = this._page ? this._page.needsRequestInterception() : false;
+    const cachePromise = info.session.send("Network.setCacheDisabled", { cacheDisabled: userInterception || hasHarRecorders });
     let fetchPromise = Promise.resolve(void 0);
     if (!info.workerFrame) {
       if (enabled)
@@ -265,13 +269,17 @@ class CRNetworkManager {
         redirectedFrom = request2;
       }
     }
+    const isInterceptedOptionsPreflight = !!requestPausedEvent && requestPausedEvent.request.method === "OPTIONS" && requestWillBeSentEvent.initiator.type === "preflight";
+    if (isInterceptedOptionsPreflight && !(this._page || this._serviceWorker).needsRequestInterception()) {
+      requestPausedSessionInfo.session._sendMayFail("Fetch.continueRequest", { requestId: requestPausedEvent.requestId });
+      return;
+    }
     let frame = requestWillBeSentEvent.frameId ? this._page?.frameManager.frame(requestWillBeSentEvent.frameId) : requestWillBeSentSessionInfo.workerFrame;
     if (!frame && this._page && requestPausedEvent && requestPausedEvent.frameId)
       frame = this._page.frameManager.frame(requestPausedEvent.frameId);
     if (!frame && this._page && requestWillBeSentEvent.frameId === (this._page?.delegate)._targetId) {
       frame = this._page.frameManager.frameAttached(requestWillBeSentEvent.frameId, null);
     }
-    const isInterceptedOptionsPreflight = !!requestPausedEvent && requestPausedEvent.request.method === "OPTIONS" && requestWillBeSentEvent.initiator.type === "preflight";
     if (isInterceptedOptionsPreflight && (this._page || this._serviceWorker).needsRequestInterception()) {
       const requestHeaders = requestPausedEvent.request.headers;
       const responseHeaders = [
@@ -518,7 +526,7 @@ class RouteImpl {
       method: overrides.method,
       postData: overrides.postData ? overrides.postData.toString("base64") : void 0
     };
-    if (overrides.url && (overrides.url === "http://patchright-init-script-inject.internal/" || overrides.url === "https://patchright-init-script-inject.internal/")) {
+    if (overrides.url && (overrides.url.startsWith("http://patchright-init-script-inject.internal") || overrides.url.startsWith("https://patchright-init-script-inject.internal"))) {
       await catchDisallowedErrors(async () => {
         this._sessionManager._alreadyTrackedNetworkIds.add(this._networkId);
         this._session._sendMayFail("Fetch.continueRequest", { requestId: this._interceptionId, interceptResponse: true });
@@ -531,8 +539,12 @@ class RouteImpl {
   }
   async fulfill(response) {
     const isTextHtml = response.headers.some((header) => header.name.toLowerCase() === "content-type" && header.value.includes("text/html"));
-    var allInjections = [...this._page.delegate._mainFrameSession._evaluateOnNewDocumentScripts];
-    if (isTextHtml && allInjections.length) {
+    const pageDelegate = this._page?.delegate || null;
+    const initScriptTag = pageDelegate?.initScriptTag || "";
+    let allInjections = [];
+    if (pageDelegate)
+      allInjections = [...pageDelegate._mainFrameSession._evaluateOnNewDocumentScripts];
+    if (isTextHtml && allInjections.length && initScriptTag) {
       let useNonce = false;
       let scriptNonce = null;
       if (response.isBase64) {
@@ -583,7 +595,7 @@ class RouteImpl {
         let scriptId = import_crypto.default.randomBytes(22).toString("hex");
         let scriptSource = script.source || script;
         const nonceAttr = useNonce ? `nonce="${scriptNonce}"` : "";
-        injectionHTML += `<script class="${this._page.delegate.initScriptTag}" ${nonceAttr} id="${scriptId}" type="text/javascript">document.getElementById("${scriptId}")?.remove();${scriptSource}</script>`;
+        injectionHTML += `<script class="${initScriptTag}" ${nonceAttr} id="${scriptId}" type="text/javascript">document.getElementById("${scriptId}")?.remove();${scriptSource}</script>`;
       });
       const lower = response.body.toLowerCase();
       const headStartIndex = lower.indexOf("<head");
@@ -771,7 +783,11 @@ class RouteImpl {
         });
       }
     } catch (error) {
-      await this._session._sendMayFail("Fetch.continueRequest", { requestId: event.requestId });
+      if (error.message.includes("Can only get response body on HeadersReceived pattern matched requests.")) {
+        await this._session.send("Fetch.continueRequest", { requestId: event.requestId, interceptResponse: true });
+      } else {
+        await this._session._sendMayFail("Fetch.continueRequest", { requestId: event.requestId });
+      }
     }
   }
 }

package/lib/server/chromium/crPage.js

@@ -110,7 +110,7 @@ class CRPage {
     while (!this._sessions.has(frame._id)) {
       const parent = frame.parentFrame();
       if (!parent)
-        throw new Error(`Frame has been detached.`);
+        throw new Error(`Frame was detached`);
       frame = parent;
     }
     return this._sessions.get(frame._id);
@@ -368,6 +368,7 @@ class FrameSession {
     ]);
   }
   async _initialize(hasUIWindow) {
+    const pageEnablePromise = this._client.send("Page.enable");
     if (!this._page.isStorageStatePage && hasUIWindow && !this._crPage._browserContext._browser.isClank() && !this._crPage._browserContext._options.noDefaultViewport) {
       const { windowId } = await this._client.send("Browser.getWindowForTarget");
       this._windowId = windowId;
@@ -378,14 +379,21 @@ class FrameSession {
     let lifecycleEventsEnabled;
     if (!this._isMainFrame())
       this._addRendererListeners();
+    let bufferedDialogEvents = this._isMainFrame() ? [] : void 0;
+    if (bufferedDialogEvents)
+      this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.javascriptDialogOpening", (event) => bufferedDialogEvents ? bufferedDialogEvents.push(event) : void 0));
     this._addBrowserListeners();
     this._bufferedAttachedToTargetEvents = [];
     const promises = [
-      this._client.send("Page.enable"),
+      pageEnablePromise,
       this._client.send("Page.getFrameTree").then(({ frameTree }) => {
         if (this._isMainFrame()) {
           this._handleFrameTree(frameTree);
           this._addRendererListeners();
+          const pendingDialogEvents = bufferedDialogEvents || [];
+          bufferedDialogEvents = void 0;
+          for (const event of pendingDialogEvents)
+            this._onDialog(event);
         }
         const attachedToTargetEvents = this._bufferedAttachedToTargetEvents || [];
         this._bufferedAttachedToTargetEvents = void 0;
@@ -400,12 +408,16 @@ class FrameSession {
         } else {
           const localFrames = this._isMainFrame() ? this._page.frames() : [this._page.frameManager.frame(this._targetId)];
           for (const frame of localFrames) {
-            this._page.frameManager.frame(frame._id)._context("utility");
+            this._page.frameManager.frame(frame._id)._context("utility").catch(() => {
+            });
             for (const binding of this._crPage._browserContext._pageBindings.values())
               frame.evaluateExpression(binding.source).catch((e) => {
               });
             for (const source of this._crPage._browserContext.initScripts)
-              frame.evaluateExpression(source).catch((e) => {
+              frame.evaluateExpression(source.source).catch((e) => {
+              });
+            for (const source of this._crPage._page.initScripts)
+              frame.evaluateExpression(source.source).catch((e) => {
               });
           }
           this._firstNonInitialNavigationCommittedFulfill();
@@ -484,6 +496,10 @@ class FrameSession {
       this._page.frameManager.frameLifecycleEvent(event.frameId, "load");
     else if (event.name === "DOMContentLoaded")
       this._page.frameManager.frameLifecycleEvent(event.frameId, "domcontentloaded");
+    if (event.name !== "load") {
+      await this._client._sendMayFail("Runtime.runIfWaitingForDebugger");
+      return;
+    }
     await this._client._sendMayFail("Runtime.runIfWaitingForDebugger");
     var document = await this._client._sendMayFail("DOM.getDocument");
     if (!document) return;
@@ -536,6 +552,14 @@ class FrameSession {
     if (!initial)
       this._firstNonInitialNavigationCommittedFulfill();
     await this._client._sendMayFail("Runtime.runIfWaitingForDebugger");
+    if (!initial) {
+      try {
+        await this._page.frameManager.frame(this._targetId)._context("utility");
+      } catch {
+      }
+      ;
+      return;
+    }
     var document = await this._client._sendMayFail("DOM.getDocument");
     if (!document) return;
     var query = await this._client._sendMayFail("DOM.querySelectorAll", {
@@ -584,7 +608,7 @@ class FrameSession {
     const delegate = new import_crExecutionContext.CRExecutionContext(this._client, contextPayload);
     let worldName = contextPayload.name;
     const context = new dom.FrameExecutionContext(delegate, frame, worldName);
-    if (worldName)
+    if (worldName && (worldName === "main" || worldName === "utility"))
       frame._contextCreated(worldName, context);
     this._contextIdToContext.set(contextPayload.id, context);
     for (const source of this._exposedBindingScripts) {
@@ -978,28 +1002,20 @@ class FrameSession {
     return (0, import_crExecutionContext.createHandle)(to, result.object).asElement();
   }
   async _initBinding(binding = import_page.PageBinding) {
-    var result = await this._client._sendMayFail("Page.createIsolatedWorld", {
-      frameId: this._targetId,
-      grantUniveralAccess: true,
-      worldName: "utility"
-    });
-    if (!result) return;
-    var isolatedContextId = result.executionContextId;
-    var globalThis = await this._client._sendMayFail("Runtime.evaluate", {
-      expression: "globalThis",
-      serializationOptions: { serialization: "idOnly" }
-    });
-    if (!globalThis) return;
-    var globalThisObjId = globalThis["result"]["objectId"];
-    var mainContextId = parseInt(globalThisObjId.split(".")[1], 10);
+    this._exposedBindingNames.push(binding.name);
+    this._exposedBindingScripts.push(binding.source);
+    const contextIds = Array.from(this._contextIdToContext.keys());
     await Promise.all([
       this._client._sendMayFail("Runtime.addBinding", { name: binding.name }),
-      this._client._sendMayFail("Runtime.addBinding", { name: binding.name, executionContextId: mainContextId }),
-      this._client._sendMayFail("Runtime.addBinding", { name: binding.name, executionContextId: isolatedContextId })
-      // this._client._sendMayFail("Runtime.evaluate", { expression: binding.source, contextId: mainContextId, awaitPromise: true })
+      ...contextIds.map((executionContextId) => this._client._sendMayFail("Runtime.addBinding", { name: binding.name, executionContextId }))
     ]);
-    this._exposedBindingNames.push(binding.name);
-    this._exposedBindingScripts.push(binding.source);
+    for (const contextId of contextIds) {
+      this._client._sendMayFail("Runtime.evaluate", {
+        expression: binding.source,
+        contextId,
+        awaitPromise: true
+      });
+    }
   }
   async _removeExposedBindings() {
     const toRetain = [];

package/lib/server/dispatchers/browserContextDispatcher.js

@@ -116,8 +116,6 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
       }
     });
     this._dialogHandler = (dialog) => {
-      if (!this._shouldDispatchEvent(dialog.page(), "dialog"))
-        return false;
       this._dispatchEvent("dialog", { dialog: new import_dialogDispatcher.DialogDispatcher(this, dialog) });
       return true;
     };

package/lib/server/frameSelectors.js

@@ -304,6 +304,11 @@ class FrameSelectors {
           const childIndex = this._findElementPositionInDomTree(element, shadowRootHandle, documentScope, currentIndex);
           if (childIndex !== null) return childIndex;
         }
+        for (const shadowChild of shadowRoot.children || []) {
+          const shadowChildIndex = (shadowRoot.children || []).indexOf(shadowChild);
+          const childIndex = this._findElementPositionInDomTree(element, shadowChild, documentScope, currentIndex + "." + shadowChildIndex.toString());
+          if (childIndex !== null) return childIndex;
+        }
       }
     }
     return null;

package/lib/server/frames.js

@@ -457,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");
@@ -596,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,
@@ -608,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,
@@ -630,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,
@@ -644,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;
@@ -660,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) {
@@ -688,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) {
@@ -719,12 +733,50 @@ 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);
@@ -760,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);
@@ -772,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];
@@ -804,7 +856,7 @@ class Frame extends import_instrumentation.SdkObject {
         this._onClearLifecycle();
         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
       });
@@ -969,10 +1021,11 @@ class Frame extends import_instrumentation.SdkObject {
       return true;
     return false;
   }
-  async _retryWithProgressIfNotConnected(progress, selector, options, 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) {
@@ -1132,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 }]) => {
@@ -1253,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")
@@ -1268,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];
@@ -1283,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";
@@ -1298,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 };
   }
@@ -1357,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(() => {
         });
@@ -1403,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;
@@ -1414,14 +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);
-          return callback(injected, handle2, taskData2);
-        }, {
-          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);
@@ -1433,8 +1531,24 @@ 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;
@@ -1527,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);
@@ -1564,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, {
@@ -1596,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;
@@ -1611,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 {
     }

package/lib/server/javascript.js

@@ -122,6 +122,8 @@ class JSHandle extends import_instrumentation.SdkObject {
         else if (isolatedContext === false) context = await frame._mainContext();
       }
     }
+    if (context !== this._context && context.adoptIfNeeded(this) === null)
+      context = this._context;
     const value = await evaluateExpression(context, expression, { ...options, returnByValue: true }, this, arg);
     await context.doSlowMo();
     return value;
@@ -135,6 +137,8 @@ class JSHandle extends import_instrumentation.SdkObject {
         else if (isolatedContext === false) context = await frame._mainContext();
       }
     }
+    if (context !== this._context && context.adoptIfNeeded(this) === null)
+      context = this._context;
     const value = await evaluateExpression(context, expression, { ...options, returnByValue: false }, this, arg);
     await context.doSlowMo();
     return value;

package/lib/server/launchApp.js

@@ -114,7 +114,8 @@ async function syncLocalStorageWithSettings(page, appName) {
           return;
         Object.entries(settings2).map(([k, v]) => localStorage[k] = v);
         window.saveSettings = () => {
-          window._saveSerializedSettings(JSON.stringify({ ...localStorage }));
+          if (typeof window._saveSerializedSettings === "function")
+            window._saveSerializedSettings(JSON.stringify({ ...localStorage }));
         };
       })})(${settings});
     `

package/lib/server/page.js

@@ -711,6 +711,32 @@ class PageBinding {
   }
   static async dispatch(page, payload, context) {
     const { name, seq, serializedArgs } = JSON.parse(payload);
+    const deliver = async (deliverPayload) => {
+      let deliveryError;
+      try {
+        await context.evaluate(import_pageBinding.deliverBindingResult, deliverPayload);
+        return;
+      } catch (e) {
+        deliveryError = e;
+      }
+      const frame = context.frame;
+      if (!frame) {
+        import_debugLogger.debugLogger.log("error", deliveryError);
+        return;
+      }
+      const mainContext = await frame._mainContext().catch(() => null);
+      const utilityContext = await frame._utilityContext().catch(() => null);
+      for (const ctx of [mainContext, utilityContext]) {
+        if (!ctx || ctx === context)
+          continue;
+        try {
+          await ctx.evaluate(import_pageBinding.deliverBindingResult, deliverPayload);
+          return;
+        } catch {
+        }
+      }
+      import_debugLogger.debugLogger.log("error", deliveryError);
+    };
     try {
       (0, import_utils.assert)(context.world);
       const binding = page.getBinding(name);
@@ -726,9 +752,9 @@ class PageBinding {
         const args = serializedArgs.map((a) => (0, import_utilityScriptSerializers.parseEvaluationResultValue)(a));
         result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, ...args);
       }
-      context.evaluate(import_pageBinding.deliverBindingResult, { name, seq, result }).catch((e) => import_debugLogger.debugLogger.log("error", e));
+      await deliver({ name, seq, result });
     } catch (error) {
-      context.evaluate(import_pageBinding.deliverBindingResult, { name, seq, error }).catch((e) => import_debugLogger.debugLogger.log("error", e));
+      await deliver({ name, seq, error });
     }
   }
 }

package/lib/server/screenshotter.js

@@ -213,6 +213,12 @@ class Screenshotter {
     if (disableAnimations)
       progress.log("  disabled all CSS animations");
     const syncAnimations = this._page.delegate.shouldToggleStyleSheetToSyncAnimations();
+    await Promise.all(this._page.frames().map(async (f) => {
+      try {
+        await f._utilityContext();
+      } catch {
+      }
+    }));
     await progress.race(this._page.safeNonStallingEvaluateInAllFrames("(" + inPagePrepareForScreenshots.toString() + `)(${JSON.stringify(screenshotStyle)}, ${hideCaret}, ${disableAnimations}, ${syncAnimations})`, "utility"));
     try {
       if (!process.env.PW_TEST_SCREENSHOT_NO_FONTS_READY) {

package/lib/server/trace/recorder/snapshotter.js

@@ -49,7 +49,7 @@ class Snapshotter {
   }
   async reset() {
     if (this._started)
-      await this._context.safeNonStallingEvaluateInAllFrames(`window["${this._snapshotStreamer}"].reset()`, "main");
+      await this._context.safeNonStallingEvaluateInAllFrames(`window["${this._snapshotStreamer}"].reset()`, "utility");
   }
   stop() {
     this._started = false;
@@ -57,20 +57,20 @@ class Snapshotter {
   async resetForReuse() {
     if (this._initScript) {
       import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
-      await this._context.removeInitScripts([this._initScript]);
       this._initScript = void 0;
+      this._initScriptSource = void 0;
     }
   }
   async _initialize() {
+    const { javaScriptEnabled } = this._context._options;
+    this._initScriptSource = `(${import_snapshotterInjected.frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === void 0})`;
+    this._initScript = true;
     for (const page of this._context.pages())
       this._onPage(page);
     this._eventListeners = [
       import_eventsHelper.eventsHelper.addEventListener(this._context, import_browserContext.BrowserContext.Events.Page, this._onPage.bind(this))
     ];
-    const { javaScriptEnabled } = this._context._options;
-    const initScriptSource = `(${import_snapshotterInjected.frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === void 0})`;
-    this._initScript = await this._context.addInitScript(void 0, initScriptSource);
-    await this._context.safeNonStallingEvaluateInAllFrames(initScriptSource, "main");
+    await this._context.safeNonStallingEvaluateInAllFrames(this._initScriptSource, "utility");
   }
   dispose() {
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
@@ -80,7 +80,7 @@ class Snapshotter {
     frame[kNeedsResetSymbol] = false;
     const expression = `window["${this._snapshotStreamer}"].captureSnapshot(${needsReset ? "true" : "false"})`;
     try {
-      return await frame.nonStallingRawEvaluateInExistingMainContext(expression);
+      return await frame.nonStallingEvaluateInExistingContext(expression, "utility");
     } catch (e) {
       frame[kNeedsResetSymbol] = true;
       import_debugLogger.debugLogger.log("error", e);
@@ -124,6 +124,7 @@ class Snapshotter {
     for (const frame of page.frames())
       this._annotateFrameHierarchy(frame);
     this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(page, import_page.Page.Events.FrameAttached, (frame) => this._annotateFrameHierarchy(frame)));
+    this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(page, import_page.Page.Events.InternalFrameNavigatedToNewDocument, (frame) => this._onFrameNavigated(frame)));
   }
   async _annotateFrameHierarchy(frame) {
     try {
@@ -131,7 +132,7 @@ class Snapshotter {
       const parent = frame.parentFrame();
       if (!parent)
         return;
-      const context = await parent._mainContext();
+      const context = await parent._utilityContext();
       await context?.evaluate(({ snapshotStreamer, frameElement: frameElement2, frameId }) => {
         window[snapshotStreamer].markIframe(frameElement2, frameId);
       }, { snapshotStreamer: this._snapshotStreamer, frameElement, frameId: frame.guid });
@@ -139,6 +140,14 @@ class Snapshotter {
     } catch (e) {
     }
   }
+  async _onFrameNavigated(frame) {
+    if (!this._initScriptSource)
+      return;
+    try {
+      await frame.nonStallingEvaluateInExistingContext(this._initScriptSource, "utility");
+    } catch (e) {
+    }
+  }
 }
 const kNeedsResetSymbol = Symbol("kNeedsReset");
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/trace/recorder/snapshotterInjected.js

@@ -60,28 +60,11 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
   class Streamer {
     constructor() {
       this._lastSnapshotNumber = 0;
-      this._staleStyleSheets = /* @__PURE__ */ new Set();
       this._modifiedStyleSheets = /* @__PURE__ */ new Set();
-      this._readingStyleSheet = false;
-      const invalidateCSSGroupingRule = (rule) => {
-        if (rule.parentStyleSheet)
-          this._invalidateStyleSheet(rule.parentStyleSheet);
-      };
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "insertRule", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "deleteRule", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "addRule", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "removeRule", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeGetter(window.CSSStyleSheet.prototype, "rules", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeGetter(window.CSSStyleSheet.prototype, "cssRules", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "replaceSync", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSGroupingRule.prototype, "insertRule", invalidateCSSGroupingRule);
-      this._interceptNativeMethod(window.CSSGroupingRule.prototype, "deleteRule", invalidateCSSGroupingRule);
-      this._interceptNativeGetter(window.CSSGroupingRule.prototype, "cssRules", invalidateCSSGroupingRule);
       this._interceptNativeSetter(window.StyleSheet.prototype, "disabled", (sheet) => {
         if (sheet instanceof CSSStyleSheet)
           this._invalidateStyleSheet(sheet);
       });
-      this._interceptNativeAsyncMethod(window.CSSStyleSheet.prototype, "replace", (sheet) => this._invalidateStyleSheet(sheet));
       this._fakeBase = document.createElement("base");
       this._observer = new MutationObserver((list) => this._handleMutations(list));
       const observerConfig = { attributes: true, subtree: true };
@@ -122,37 +105,6 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
           delete event.composedPath()[0].__playwright_target__;
       });
     }
-    _interceptNativeMethod(obj, method, cb) {
-      const native = obj[method];
-      if (!native)
-        return;
-      obj[method] = function(...args) {
-        const result = native.call(this, ...args);
-        cb(this, result);
-        return result;
-      };
-    }
-    _interceptNativeAsyncMethod(obj, method, cb) {
-      const native = obj[method];
-      if (!native)
-        return;
-      obj[method] = async function(...args) {
-        const result = await native.call(this, ...args);
-        cb(this, result);
-        return result;
-      };
-    }
-    _interceptNativeGetter(obj, prop, cb) {
-      const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
-      Object.defineProperty(obj, prop, {
-        ...descriptor,
-        get: function() {
-          const result = descriptor.get.call(this);
-          cb(this, result);
-          return result;
-        }
-      });
-    }
     _interceptNativeSetter(obj, prop, cb) {
       const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
       Object.defineProperty(obj, prop, {
@@ -168,44 +120,37 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
       for (const mutation of list)
         ensureCachedData(mutation.target).attributesCached = void 0;
     }
-    _invalidateStyleSheet(sheet) {
-      if (this._readingStyleSheet)
-        return;
-      this._staleStyleSheets.add(sheet);
-      if (sheet.href !== null)
-        this._modifiedStyleSheets.add(sheet);
-    }
     _updateStyleElementStyleSheetTextIfNeeded(sheet, forceText) {
       const data = ensureCachedData(sheet);
-      if (this._staleStyleSheets.has(sheet) || forceText && data.cssText === void 0) {
-        this._staleStyleSheets.delete(sheet);
-        try {
-          data.cssText = this._getSheetText(sheet);
-        } catch (e) {
-          data.cssText = "";
-        }
+      try {
+        data.cssText = this._getSheetText(sheet);
+      } catch (e) {
+        data.cssText = "";
       }
       return data.cssText;
     }
     // Returns either content, ref, or no override.
     _updateLinkStyleSheetTextIfNeeded(sheet, snapshotNumber) {
       const data = ensureCachedData(sheet);
-      if (this._staleStyleSheets.has(sheet)) {
-        this._staleStyleSheets.delete(sheet);
-        try {
-          data.cssText = this._getSheetText(sheet);
-          data.cssRef = snapshotNumber;
-          return data.cssText;
-        } catch (e) {
+      try {
+        const currentText = this._getSheetText(sheet);
+        if (data.cssText === void 0) {
+          data.cssText = currentText;
+          return void 0;
         }
+        if (currentText === data.cssText)
+          return data.cssRef === void 0 ? void 0 : snapshotNumber - data.cssRef;
+        data.cssText = currentText;
+        data.cssRef = snapshotNumber;
+        return data.cssText;
+      } catch (e) {
+        return void 0;
       }
-      return data.cssRef === void 0 ? void 0 : snapshotNumber - data.cssRef;
     }
     markIframe(iframeElement, frameId) {
       iframeElement[kSnapshotFrameId] = frameId;
     }
     reset() {
-      this._staleStyleSheets.clear();
       const visitNode = (node) => {
         resetCachedData(node);
         if (node.nodeType === Node.ELEMENT_NODE) {
@@ -264,17 +209,10 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
       return document.baseURI;
     }
     _getSheetText(sheet) {
-      this._readingStyleSheet = true;
-      try {
-        if (sheet.disabled)
-          return "";
-        const rules = [];
-        for (const rule of sheet.cssRules)
-          rules.push(rule.cssText);
-        return rules.join("\n");
-      } finally {
-        this._readingStyleSheet = false;
-      }
+      const rules = [];
+      for (const rule of sheet.cssRules)
+        rules.push(rule.cssText);
+      return rules.join("\n");
     }
     captureSnapshot(needsReset) {
       const timestamp = performance.now();

package/lib/server/trace/recorder/tracing.js

@@ -550,6 +550,8 @@ function shouldCaptureSnapshot(metadata) {
   return !!metainfo?.snapshot;
 }
 function createBeforeActionTraceEvent(metadata, parentId) {
+  if (metadata.type === "Route" && metadata.method === "continue" && metadata.params?.isFallback)
+    return null;
   if (metadata.internal || metadata.method.startsWith("tracing"))
     return null;
   const event = {
@@ -568,6 +570,8 @@ function createBeforeActionTraceEvent(metadata, parentId) {
   return event;
 }
 function createInputActionTraceEvent(metadata) {
+  if (metadata.type === "Route" && metadata.method === "continue" && metadata.params?.isFallback)
+    return null;
   if (metadata.internal || metadata.method.startsWith("tracing"))
     return null;
   return {
@@ -577,6 +581,8 @@ function createInputActionTraceEvent(metadata) {
   };
 }
 function createActionLogTraceEvent(metadata, message) {
+  if (metadata.type === "Route" && metadata.method === "continue" && metadata.params?.isFallback)
+    return null;
   if (metadata.internal || metadata.method.startsWith("tracing"))
     return null;
   return {
@@ -587,6 +593,8 @@ function createActionLogTraceEvent(metadata, message) {
   };
 }
 function createAfterActionTraceEvent(metadata) {
+  if (metadata.type === "Route" && metadata.method === "continue" && metadata.params?.isFallback)
+    return null;
   if (metadata.internal || metadata.method.startsWith("tracing"))
     return null;
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "phantomwright-driver-core",
-    "version": "v1.58.2",
+    "version": "1.58.3",
     "description": "A high-level API to automate web browsers",
     "repository": {
         "type": "git",