patchright.patch

# NOTE: This patch file is generated automatically and is not used, it is only for documentation. The driver is actually patched using [patchright_driver_patch](https://github.com/Kaliiiiiiiiii-Vinyzu/patchright/blob/main/patchright_driver_patch.ts), see [the workflow](https://github.com/Kaliiiiiiiiii-Vinyzu/patchright/blob/main/.github/workflows/patch_file_updater.yml)
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/cli/program.ts patchright/node_modules/playwright-core/src/cli/program.ts
---
+++
@@ -1,21 +1,3 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable no-console */
-
 import '../bootstrap';
 import { gracefullyProcessExitDoNotHang, getPackageManagerExecCommand } from '../utils';
 import { addTraceCommands } from '../tools/trace/traceCli';
@@ -69,10 +51,10 @@
 
 program
     .command('install [browser...]')
-    .description('ensure browsers necessary for this version of Playwright are installed')
+    .description('ensure browsers necessary for this version of Patchright are installed')
     .option('--with-deps', 'install system dependencies for browsers')
     .option('--dry-run', 'do not execute installation, only print information')
-    .option('--list', 'prints list of browsers from all playwright installations')
+    .option('--list', 'prints list of browsers from all patchright installations')
     .option('--force', 'force reinstall of already installed browsers')
     .option('--only-shell', 'only install headless shell when installing chromium')
     .option('--no-shell', 'do not install chromium headless shell')
@@ -95,8 +77,8 @@
 
 program
     .command('uninstall')
-    .description('Removes browsers used by this installation of Playwright from the system (chromium, firefox, webkit, ffmpeg). This does not include branded channels.')
-    .option('--all', 'Removes all browsers used by any Playwright installation from the system.')
+    .description('Removes browsers used by this installation of Patchright from the system (chromium, firefox, webkit, ffmpeg). This does not include branded channels.')
+    .option('--all', 'Removes all browsers used by any Patchright installation from the system.')
     .action(async (options: { all?: boolean }) => {
       const { uninstallBrowsers } = await import('./installActions');
       uninstallBrowsers(options).catch(logErrorAndExit);
@@ -284,7 +266,7 @@
       .option('--save-har-glob <glob pattern>', 'filter entries in the HAR by matching url against this glob pattern')
       .option('--save-storage <filename>', 'save context storage state at the end, for later use with --load-storage')
       .option('--timezone <time zone>', 'time zone to emulate, for example "Europe/Rome"')
-      .option('--timeout <timeout>', 'timeout for Playwright actions in milliseconds, no timeout by default')
+      .option('--timeout <timeout>', 'timeout for Patchright actions in milliseconds, no timeout by default')
       .option('--user-agent <ua string>', 'specify user agent string')
       .option('--user-data-dir <directory>', 'use the specified user data directory instead of a new context')
       .option('--viewport-size <size>', 'specify browser viewport size in pixels, for example "1280, 720"');
@@ -293,14 +275,14 @@
 function buildBasePlaywrightCLICommand(cliTargetLang: string | undefined): string {
   switch (cliTargetLang) {
     case 'python':
-      return `playwright`;
+      return `patchright`;
     case 'java':
       return `mvn exec:java -e -D exec.mainClass=com.microsoft.playwright.CLI -D exec.args="...options.."`;
     case 'csharp':
       return `pwsh bin/Debug/netX/playwright.ps1`;
     default: {
       const packageManagerCommand = getPackageManagerExecCommand();
-      return `${packageManagerCommand} playwright`;
+      return `${packageManagerCommand} patchright`;
     }
   }
 }
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/cli/programWithTestStub.ts patchright/node_modules/playwright-core/src/cli/programWithTestStub.ts
---
+++
@@ -1,21 +1,3 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable no-console */
-
 import { gracefullyProcessExitDoNotHang } from '../server/utils/processLauncher';
 import { getPackageManager } from '../utils';
 import { program } from './program';
@@ -34,24 +16,24 @@
     packages.push('playwright');
   const packageManager = getPackageManager();
   if (packageManager === 'yarn') {
-    console.error(`Please install @playwright/test package before running "yarn playwright ${command}"`);
+    console.error(`Please install @playwright/test package before running "yarn patchright ${command}"`);
     console.error(`  yarn remove ${packages.join(' ')}`);
     console.error('  yarn add -D @playwright/test');
   } else if (packageManager === 'pnpm') {
-    console.error(`Please install @playwright/test package before running "pnpm exec playwright ${command}"`);
+    console.error(`Please install @playwright/test package before running "pnpm exec patchright ${command}"`);
     console.error(`  pnpm remove ${packages.join(' ')}`);
     console.error('  pnpm add -D @playwright/test');
   } else {
-    console.error(`Please install @playwright/test package before running "npx playwright ${command}"`);
+    console.error(`Please install @playwright/test package before running "npx patchright ${command}"`);
     console.error(`  npm uninstall ${packages.join(' ')}`);
     console.error('  npm install -D @playwright/test');
   }
 }
 
 const kExternalPlaywrightTestCommands = [
-  ['test', 'Run tests with Playwright Test.'],
-  ['show-report', 'Show Playwright Test HTML report.'],
-  ['merge-reports', 'Merge Playwright Test Blob reports'],
+  ['test', 'Run tests with Patchright Test.'],
+  ['show-report', 'Show Patchright Test HTML report.'],
+  ['merge-reports', 'Merge Patchright Test Blob reports'],
 ];
 function addExternalPlaywrightTestCommands() {
   for (const [command, description] of kExternalPlaywrightTestCommands) {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/client/browserContext.ts patchright/node_modules/playwright-core/src/client/browserContext.ts
---
+++
@@ -146,9 +146,9 @@
         // a) removing "dialog" listener subscription (client->server)
         // b) actual "dialog" event (server->client)
         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), Page.fromNullable(page)));
@@ -356,17 +356,20 @@
   }
 
   async addInitScript(script: Function | string | { path?: string, content?: string }, arg?: any) {
+    await this.installInjectRoute();
     const source = await evaluationScript(this._platform, script, arg);
     return DisposableObject.from((await this._channel.addInitScript({ source })).disposable);
   }
 
   async exposeBinding(name: string, callback: (source: structs.BindingSource, ...args: any[]) => any, options: { handle?: boolean } = {}): Promise<DisposableObject> {
+    await this.installInjectRoute();
     const result = await this._channel.exposeBinding({ name, needsHandle: options.handle });
     this._bindings.set(name, callback);
     return DisposableObject.from(result.disposable);
   }
 
   async exposeFunction(name: string, callback: Function): Promise<DisposableObject> {
+    await this.installInjectRoute();
     const result = await this._channel.exposeBinding({ name });
     const binding = (source: structs.BindingSource, ...args: any[]) => callback(...args);
     this._bindings.set(name, binding);
@@ -560,6 +563,25 @@
     await this._channel.exposeConsoleApi();
   }
 
+  routeInjecting: boolean = false;
+
+  async installInjectRoute() {
+
+      if (this.routeInjecting) return;
+        await this.route('**/*', async route => {
+        try {
+            if (route.request().resourceType() === 'document' && route.request().url().startsWith('http')) {
+                const protocol = route.request().url().split(':')[0];
+                await route.fallback({ url: protocol + '://patchright-init-script-inject.internal/' });
+            } else {
+                await route.fallback();
+            }
+        } catch (error) {
+            await route.fallback();
+        }
+      });
+      this.routeInjecting = true;
+  }
 }
 
 async function prepareStorageState(platform: Platform, storageState: string | SetStorageState): Promise<NonNullable<channels.BrowserNewContextParams['storageState']>> {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/client/clientHelper.ts patchright/node_modules/playwright-core/src/client/clientHelper.ts
---
+++
@@ -50,5 +50,5 @@
 }
 
 export function addSourceUrlToScript(source: string, path: string): string {
-  return `${source}\n//# sourceURL=${path.replace(/\n/g, '')}`;
+  return source
 }
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/client/clock.ts patchright/node_modules/playwright-core/src/client/clock.ts
---
+++
@@ -25,6 +25,7 @@
   }
 
   async install(options: { time?: number | string | Date } = { }) {
+    await this._browserContext.installInjectRoute()
     await this._browserContext._channel.clockInstall(options.time !== undefined ? parseTime(options.time) : {});
   }
 
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/client/frame.ts patchright/node_modules/playwright-core/src/client/frame.ts
---
+++
@@ -177,25 +177,33 @@
   }
 
   async waitForURL(url: URLMatch, options: { waitUntil?: LifecycleEvent, timeout?: number } = {}): Promise<void> {
-    if (urlMatches(this._page?.context()._options.baseURL, this.url(), url))
-      return await this.waitForLoadState(options.waitUntil, options);
 
-    await this.waitForNavigation({ url, ...options });
+      if (urlMatches(this._page?.context()._options.baseURL, this.url(), url))
+        return await this.waitForLoadState(options.waitUntil, options);
+      try {
+        await this.waitForNavigation({ url, ...options });
+      } catch (error) {
+        if (urlMatches(this._page?.context()._options.baseURL, this.url(), url)) {
+          await this.waitForLoadState(options.waitUntil, options);
+          return;
+        }
+        throw error;
+      }
   }
 
   async frameElement(): Promise<ElementHandle> {
     return ElementHandle.from((await this._channel.frameElement()).element);
   }
 
-  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<structs.SmartHandle<R>> {
-    assertMaxArguments(arguments.length, 2);
-    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
+  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<structs.SmartHandle<R>> {
+    assertMaxArguments(arguments.length, 3);
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
     return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
   }
 
-  async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<R> {
-    assertMaxArguments(arguments.length, 2);
-    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
+  async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<R> {
+    assertMaxArguments(arguments.length, 3);
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
     return parseResult(result.value);
   }
 
@@ -231,9 +239,9 @@
     return parseResult(result.value);
   }
 
-  async $$eval<R, Arg>(selector: string, pageFunction: structs.PageFunctionOn<Element[], Arg, R>, arg?: Arg): Promise<R> {
-    assertMaxArguments(arguments.length, 3);
-    const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
+  async $$eval<R, Arg>(selector: string, pageFunction: structs.PageFunctionOn<Element[], Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<R> {
+    assertMaxArguments(arguments.length, 4);
+    const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
     return parseResult(result.value);
   }
 
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/client/jsHandle.ts patchright/node_modules/playwright-core/src/client/jsHandle.ts
---
+++
@@ -36,14 +36,16 @@
     this._channel.on('previewUpdated', ({ preview }) => this._preview = preview);
   }
 
-  async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg): Promise<R> {
-    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
-    return parseResult(result.value);
+  async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<R> {
+
+      const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
+      return parseResult(result.value);
   }
 
-  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg): Promise<structs.SmartHandle<R>> {
-    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
-    return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
+  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<structs.SmartHandle<R>> {
+
+      const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
+      return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
   }
 
   async getProperty(propertyName: string): Promise<JSHandle> {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/client/locator.ts patchright/node_modules/playwright-core/src/client/locator.ts
---
+++
@@ -1,3 +1,5 @@
+// undetected-undetected_playwright-patch - custom imports
+import { JSHandle, parseResult, serializeArgument } from './jsHandle';
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -124,16 +126,52 @@
     });
   }
 
-  async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<SVGElement | HTMLElement, Arg, R>, arg?: Arg, options?: TimeoutOptions): Promise<R> {
-    return await this._withElement(h => h.evaluate(pageFunction, arg), { title: 'Evaluate', timeout: options?.timeout });
+  async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<SVGElement | HTMLElement, Arg, R>, arg?: Arg, options?: TimeoutOptions, isolatedContext: boolean = true): Promise<R> {
+
+      if (typeof options === 'boolean') {
+        isolatedContext = options;
+        options = undefined;
+      }
+      return await this._withElement(
+        async (h) =>
+          parseResult(
+            (
+              await h._channel.evaluateExpression({
+                expression: String(pageFunction),
+                isFunction: typeof pageFunction === "function",
+                arg: serializeArgument(arg),
+                isolatedContext: isolatedContext,
+              })
+            ).value
+          ),
+        { title: "Evaluate", timeout: options?.timeout }
+      );
   }
 
-  async evaluateAll<R, Arg>(pageFunction: structs.PageFunctionOn<Element[], Arg, R>, arg?: Arg): Promise<R> {
-    return await this._frame.$$eval(this._selector, pageFunction, arg);
+  async evaluateAll<R, Arg>(pageFunction: structs.PageFunctionOn<Element[], Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<R> {
+    return await this._frame.$$eval(this._selector, pageFunction, arg, isolatedContext);
   }
 
-  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<any, Arg, R>, arg?: Arg, options?: TimeoutOptions): Promise<structs.SmartHandle<R>> {
-    return await this._withElement(h => h.evaluateHandle(pageFunction, arg), { title: 'Evaluate', timeout: options?.timeout });
+  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<any, Arg, R>, arg?: Arg, options?: TimeoutOptions, isolatedContext: boolean = true): Promise<structs.SmartHandle<R>> {
+
+      if (typeof options === 'boolean') {
+        isolatedContext = options;
+        options = undefined;
+      }
+      return await this._withElement(
+        async (h) =>
+          JSHandle.from(
+            (
+              await h._channel.evaluateExpressionHandle({
+                expression: String(pageFunction),
+                isFunction: typeof pageFunction === "function",
+                arg: serializeArgument(arg),
+                isolatedContext: isolatedContext,
+              })
+            ).handle
+          ) as any as structs.SmartHandle<R>,
+        { title: "Evaluate", timeout: options?.timeout }
+      );
   }
 
   async fill(value: string, options: channels.ElementHandleFillOptions & TimeoutOptions = {}): Promise<void> {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/client/network.ts patchright/node_modules/playwright-core/src/client/network.ts
---
+++
@@ -15,7 +15,7 @@
  */
 
 import { ChannelOwner } from './channelOwner';
-import { isTargetClosedError } from './errors';
+import { isTargetClosedError, TargetClosedError } from './errors';
 import { Events } from './events';
 import { APIResponse } from './fetch';
 import { Frame } from './frame';
@@ -183,7 +183,12 @@
   }
 
   async allHeaders(): Promise<Headers> {
-    return (await this._actualHeaders()).headers();
+
+      const headers = await this._actualHeaders();
+      const page = this._safePage();
+      if (page?._closeWasCalled)
+        throw new TargetClosedError();
+      return headers.headers();
   }
 
   async headersArray(): Promise<HeadersArray> {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/client/page.ts patchright/node_modules/playwright-core/src/client/page.ts
---
+++
@@ -313,9 +313,9 @@
     return await this._mainFrame.dispatchEvent(selector, type, eventInit, options);
   }
 
-  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<structs.SmartHandle<R>> {
-    assertMaxArguments(arguments.length, 2);
-    return await this._mainFrame.evaluateHandle(pageFunction, arg);
+  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<structs.SmartHandle<R>> {
+    assertMaxArguments(arguments.length, 3);
+    return await this._mainFrame.evaluateHandle(pageFunction, arg, isolatedContext);
   }
 
   async $eval<R, Arg>(selector: string, pageFunction: structs.PageFunctionOn<Element, Arg, R>, arg?: Arg): Promise<R> {
@@ -341,6 +341,7 @@
   }
 
   async exposeFunction(name: string, callback: Function) {
+    await this.installInjectRoute();
     const result = await this._channel.exposeBinding({ name });
     const binding = (source: structs.BindingSource, ...args: any[]) => callback(...args);
     this._bindings.set(name, binding);
@@ -348,6 +349,7 @@
   }
 
   async exposeBinding(name: string, callback: (source: structs.BindingSource, ...args: any[]) => any, options: { handle?: boolean } = {}) {
+    await this.installInjectRoute();
     const result = await this._channel.exposeBinding({ name, needsHandle: options.handle });
     this._bindings.set(name, callback);
     return DisposableObject.from(result.disposable);
@@ -507,12 +509,13 @@
     return this._viewportSize || null;
   }
 
-  async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<R> {
-    assertMaxArguments(arguments.length, 2);
-    return await this._mainFrame.evaluate(pageFunction, arg);
+  async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<R> {
+    assertMaxArguments(arguments.length, 3);
+    return await this._mainFrame.evaluate(pageFunction, arg, isolatedContext);
   }
 
   async addInitScript(script: Function | string | { path?: string, content?: string }, arg?: any) {
+    await this.installInjectRoute();
     const source = await evaluationScript(this._platform, script, arg);
     return DisposableObject.from((await this._channel.addInitScript({ source })).disposable);
   }
@@ -864,6 +867,26 @@
   async _setDockTile(image: Buffer) {
     await this._channel.setDockTile({ image });
   }
+
+  routeInjecting: boolean = false;
+
+  async installInjectRoute() {
+
+      if (this.routeInjecting || this.context().routeInjecting) return;
+      await this.route('**/*', async route => {
+        try {
+          if (route.request().resourceType() === 'document' && route.request().url().startsWith('http')) {
+              const protocol = route.request().url().split(':')[0];
+              await route.fallback({ url: protocol + '://patchright-init-script-inject.internal/' });
+          } else {
+              await route.fallback();
+          }
+      } catch (error) {
+          await route.fallback();
+        }
+      });
+      this.routeInjecting = true;
+  }
 }
 
 export class BindingCall extends ChannelOwner<channels.BindingCallChannel> {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/client/tracing.ts patchright/node_modules/playwright-core/src/client/tracing.ts
---
+++
@@ -38,6 +38,7 @@
   }
 
   async start(options: { name?: string, title?: string, snapshots?: boolean, screenshots?: boolean, sources?: boolean, live?: boolean } = {}) {
+    if (typeof this._parent.installInjectRoute === 'function') await this._parent.installInjectRoute();
     await this._wrapApiCall(async () => {
       this._includeSources = !!options.sources;
       this._isLive = !!options.live;
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/client/worker.ts patchright/node_modules/playwright-core/src/client/worker.ts
---
+++
@@ -62,15 +62,15 @@
     return this._initializer.url;
   }
 
-  async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<R> {
-    assertMaxArguments(arguments.length, 2);
-    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
+  async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<R> {
+    assertMaxArguments(arguments.length, 3);
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
     return parseResult(result.value);
   }
 
-  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<structs.SmartHandle<R>> {
-    assertMaxArguments(arguments.length, 2);
-    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
+  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<structs.SmartHandle<R>> {
+    assertMaxArguments(arguments.length, 3);
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
     return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
   }
 
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/android/android.ts patchright/node_modules/playwright-core/src/server/android/android.ts
---
+++
@@ -1,19 +1,3 @@
-/**
- * Copyright Microsoft Corporation. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 import { EventEmitter } from 'events';
 import fs from 'fs';
 import os from 'os';
@@ -184,7 +168,7 @@
       for (const file of ['android-driver.apk', 'android-driver-target.apk']) {
         const fullName = path.join(executable.directory!, file);
         if (!fs.existsSync(fullName))
-          throw new Error(`Please install Android driver apk using '${packageManagerCommand} playwright install android'`);
+          throw new Error(`Please install Android driver apk using '${packageManagerCommand} patchright install android'`);
         await this.installApk(progress, await progress.race(fs.promises.readFile(fullName)));
       }
     } else {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/browserContext.ts patchright/node_modules/playwright-core/src/server/browserContext.ts
---
+++
@@ -167,7 +167,7 @@
       await this.exposeConsoleApi();
 
     if (this._options.serviceWorkers === 'block')
-      await this.addInitScript(`\nif (navigator.serviceWorker) navigator.serviceWorker.register = async () => { console.warn('Service Worker registration blocked by Playwright'); };\n`);
+      await this.addInitScript(`if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { };`);
 
     if (this._options.permissions)
       await this.grantPermissions(this._options.permissions);
@@ -352,18 +352,13 @@
       if (page.getBinding(name))
         throw new Error(`Function "${name}" has been already registered in one of the pages`);
     }
-    await progress.race(this.exposePlaywrightBindingIfNeeded());
     const binding = new PageBinding(this, name, playwrightBinding, needsHandle);
     binding.forClient = forClient;
     this._pageBindings.set(name, binding);
-    try {
-      await progress.race(this.doAddInitScript(binding.initScript));
-      await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, 'main'));
-      return binding;
-    } catch (error) {
-      this._pageBindings.delete(name);
-      throw error;
-    }
+    
+    				await this.doExposeBinding(binding);
+    				return binding;
+    			
   }
 
   async removeExposedBinding(binding: PageBinding) {
@@ -881,4 +876,5 @@
   strictSelectors: false,
   serviceWorkers: 'allow',
   locale: 'en-US',
+  focusControl: false
 };
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/chromium/chromium.ts patchright/node_modules/playwright-core/src/server/chromium/chromium.ts
---
+++
@@ -320,8 +320,6 @@
     const chromeArguments = [...chromiumSwitches(options.assistantMode, options.channel)];
 
     // See https://issues.chromium.org/issues/40277080
-    chromeArguments.push('--enable-unsafe-swiftshader');
-
     if (options.headless) {
       chromeArguments.push('--headless');
 
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/chromium/chromiumSwitches.ts patchright/node_modules/playwright-core/src/server/chromium/chromiumSwitches.ts
---
+++
@@ -51,26 +51,16 @@
   '--disable-field-trial-config', // https://source.chromium.org/chromium/chromium/src/+/main:testing/variations/README.md
   '--disable-background-networking',
   '--disable-background-timer-throttling',
-  '--disable-backgrounding-occluded-windows',
-  '--disable-back-forward-cache', // Avoids surprises like main request not being intercepted during page.goBack().
-  '--disable-breakpad',
-  '--disable-client-side-phishing-detection',
-  '--disable-component-extensions-with-background-pages',
-  '--disable-component-update', // Avoids unneeded network activity after startup.
+  '--disable-backgrounding-occluded-windows', // Avoids surprises like main request not being intercepted during page.goBack().
+  '--disable-breakpad', // Avoids unneeded network activity after startup.
   '--no-default-browser-check',
-  '--disable-default-apps',
   '--disable-dev-shm-usage',
-  '--disable-extensions',
   '--disable-features=' + disabledFeatures(assistantMode).join(','),
   process.env.PLAYWRIGHT_LEGACY_SCREENSHOT ? '' : '--enable-features=CDPScreenshotNewSurface',
-  '--allow-pre-commit-input',
   '--disable-hang-monitor',
-  '--disable-ipc-flooding-protection',
-  '--disable-popup-blocking',
   '--disable-prompt-on-repost',
   '--disable-renderer-backgrounding',
   '--force-color-profile=srgb',
-  '--metrics-recording-only',
   '--no-first-run',
   '--password-store=basic',
   '--use-mock-keychain',
@@ -79,11 +69,8 @@
   '--export-tagged-pdf',
   // https://chromium-review.googlesource.com/c/chromium/src/+/4853540
   '--disable-search-engine-choice-screen',
-  // https://issues.chromium.org/41491762
-  '--unsafely-disable-devtools-self-xss-warnings',
   // Edge can potentially restart on Windows (msRelaunchNoCompatLayer) which looses its file descriptors (stdout/stderr) and CDP (3/4). Disable until fixed upstream.
   '--edge-skip-compat-layer-relaunch',
-  assistantMode ? '' : '--enable-automation',
   // This disables Chrome for Testing infobar that is visible in the persistent context.
   // The switch is ignored everywhere else, including Chromium/Chrome/Edge.
   '--disable-infobars',
@@ -91,4 +78,5 @@
   '--disable-search-engine-choice-screen',
   // Prevents the "three dots" menu crash in IdentityManager::HasPrimaryAccount for ephemeral contexts.
   android ? '' : '--disable-sync',
+  '--disable-blink-features=AutomationControlled'
 ].filter(Boolean);
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/chromium/crBrowser.ts patchright/node_modules/playwright-core/src/server/chromium/crBrowser.ts
---
+++
@@ -522,8 +522,10 @@
   }
 
   async doRemoveInitScripts(initScripts: InitScript[]) {
-    for (const page of this.pages())
-      await (page.delegate as CRPage).removeInitScripts(initScripts);
+
+    		for (const page of this.pages())
+    			await (page.delegate as CRPage).removeInitScripts(initScripts);
+    	
   }
 
   async doUpdateRequestInterception(): Promise<void> {
@@ -611,6 +613,20 @@
     const rootSession = await this._browser._clientRootSession();
     return rootSession.attachToTarget(targetId);
   }
+
+  async doExposeBinding(binding: PageBinding) {
+
+    		for (const page of this.pages())
+    			await (page.delegate as CRPage).exposeBinding(binding);
+    	
+  }
+
+  async doRemoveExposedBindings() {
+
+    		for (const page of this.pages())
+    			await (page.delegate as CRPage).removeExposedBindings();
+    	
+  }
 }
 
 export function shouldProxyLoopback(bypass: string | undefined) {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/chromium/crCoverage.ts patchright/node_modules/playwright-core/src/server/chromium/crCoverage.ts
---
+++
@@ -82,10 +82,13 @@
     this._scriptIds.clear();
     this._scriptSources.clear();
     this._eventListeners = [
-      eventsHelper.addEventListener(this._client, 'Debugger.scriptParsed', this._onScriptParsed.bind(this)),
-      eventsHelper.addEventListener(this._client, 'Runtime.executionContextsCleared', this._onExecutionContextsCleared.bind(this)),
-      eventsHelper.addEventListener(this._client, 'Debugger.paused', this._onDebuggerPaused.bind(this)),
-    ];
+          eventsHelper.addEventListener(this._client, 'Debugger.scriptParsed', this._onScriptParsed.bind(this)),
+          
+    						eventsHelper.addEventListener(this._client, 'Runtime.executionContextsCleared', this._onExecutionContextsCleared.bind(this)),
+    						eventsHelper.addEventListener(this._client, 'Page.frameNavigated', this._onFrameNavigated.bind(this)),
+    					
+          eventsHelper.addEventListener(this._client, 'Debugger.paused', this._onDebuggerPaused.bind(this)),
+        ];
     await Promise.all([
       this._client.send('Profiler.enable'),
       this._client.send('Profiler.startPreciseCoverage', { callCount: true, detailed: true }),
@@ -142,6 +145,11 @@
     }
     return coverage;
   }
+
+  _onFrameNavigated(event: Protocol.Page.frameNavigatedPayload) {
+    if (event.frame.parentId) return;
+    this._onExecutionContextsCleared();
+  }
 }
 
 class CSSCoverage {
@@ -169,9 +177,12 @@
     this._stylesheetURLs.clear();
     this._stylesheetSources.clear();
     this._eventListeners = [
-      eventsHelper.addEventListener(this._client, 'CSS.styleSheetAdded', this._onStyleSheet.bind(this)),
-      eventsHelper.addEventListener(this._client, 'Runtime.executionContextsCleared', this._onExecutionContextsCleared.bind(this)),
-    ];
+          eventsHelper.addEventListener(this._client, 'CSS.styleSheetAdded', this._onStyleSheet.bind(this)),
+          
+    						eventsHelper.addEventListener(this._client, 'Runtime.executionContextsCleared', this._onExecutionContextsCleared.bind(this)),
+    						eventsHelper.addEventListener(this._client, 'Page.frameNavigated', this._onFrameNavigated.bind(this)),
+    					
+        ];
     await Promise.all([
       this._client.send('DOM.enable'),
       this._client.send('CSS.enable'),
@@ -235,6 +246,11 @@
 
     return coverage;
   }
+
+  _onFrameNavigated(event: Protocol.Page.frameNavigatedPayload) {
+    if (event.frame.parentId) return;
+    this._onExecutionContextsCleared();
+  }
 }
 
 function convertToDisjointRanges(nestedRanges: {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/chromium/crDevTools.ts patchright/node_modules/playwright-core/src/server/chromium/crDevTools.ts
---
+++
@@ -64,7 +64,6 @@
       }).catch(e => null);
     });
     Promise.all([
-      session.send('Runtime.enable'),
       session.send('Runtime.addBinding', { name: kBindingName }),
       session.send('Page.enable'),
       session.send('Page.addScriptToEvaluateOnNewDocument', { source: `
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/chromium/crNetworkManager.ts patchright/node_modules/playwright-core/src/server/chromium/crNetworkManager.ts
---
+++
@@ -30,7 +30,7 @@
 import type * as types from '../types';
 import type { CRPage } from './crPage';
 import type { CRServiceWorker } from './crServiceWorker';
-
+import crypto from "crypto";
 
 type SessionInfo = {
   session: CRSession;
@@ -97,6 +97,7 @@
     if (info)
       eventsHelper.removeEventListeners(info.eventListeners);
     this._sessions.delete(session);
+    if (!this._sessions.size) this._alreadyTrackedNetworkIds.clear();
   }
 
   private async _forEachSession(cb: (sessionInfo: SessionInfo) => Promise<any>) {
@@ -142,6 +143,10 @@
   async setRequestInterception(value: boolean) {
     this._userRequestInterceptionEnabled = value;
     await this._updateProtocolRequestInterception();
+
+    			if (this._page)
+    				await this._forEachSession(info => info.session.send('Network.setCacheDisabled', { cacheDisabled: this._page.needsRequestInterception() }));
+    		
   }
 
   async _updateProtocolRequestInterception() {
@@ -156,7 +161,11 @@
     const enabled = this._protocolRequestInterceptionEnabled;
     if (initial && !enabled)
       return;
-    const cachePromise = info.session.send('Network.setCacheDisabled', { cacheDisabled: enabled });
+    
+    				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<any>(undefined);
     if (!info.workerFrame) {
       if (enabled)
@@ -238,6 +247,7 @@
   }
 
   _onRequestPaused(sessionInfo: SessionInfo, event: Protocol.Fetch.requestPausedPayload) {
+    if (this._alreadyTrackedNetworkIds.has(event.networkId)) return;
     if (!event.networkId) {
       // Fetch without networkId means that request was not recognized by inspector, and
       // it will never receive Network.requestWillBeSent. Continue the request to not affect it.
@@ -276,6 +286,10 @@
   }
 
   _onRequest(requestWillBeSentSessionInfo: SessionInfo, requestWillBeSentEvent: Protocol.Network.requestWillBeSentPayload, requestPausedSessionInfo: SessionInfo | undefined, requestPausedEvent: Protocol.Fetch.requestPausedPayload | undefined) {
+
+    			if (this._alreadyTrackedNetworkIds.has(requestWillBeSentEvent.requestId))
+    				return;
+    		
     if (requestWillBeSentEvent.request.url.startsWith('data:'))
       return;
     let redirectedFrom: InterceptableRequest | null = null;
@@ -287,6 +301,13 @@
         redirectedFrom = request;
       }
     }
+    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;
     // Requests from workers lack frameId, because we receive Network.requestWillBeSent
     // on the worker target. However, we receive Fetch.requestPaused on the page target,
@@ -306,7 +327,6 @@
     // we accept all CORS options, assuming that this was intended when setting route.
     //
     // Note: it would be better to match the URL against interception patterns.
-    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: Protocol.Fetch.HeaderEntry[] = [
@@ -346,7 +366,7 @@
         }
         requestPausedSessionInfo!.session._sendMayFail('Fetch.continueRequest', { requestId: requestPausedEvent.requestId, headers: headersOverride });
       } else {
-        route = new RouteImpl(requestPausedSessionInfo!.session, requestPausedEvent.requestId);
+        route = new RouteImpl(requestPausedSessionInfo!.session, requestPausedEvent.requestId, this._page, requestPausedEvent.networkId ?? requestPausedEvent.requestId, this);
       }
     }
     const isNavigationRequest = requestWillBeSentEvent.requestId === requestWillBeSentEvent.loaderId && requestWillBeSentEvent.type === 'Document';
@@ -558,6 +578,8 @@
     if (request.session !== sessionInfo.session && !sessionInfo.isMain && (request._documentId === request._requestId || sessionInfo.workerFrame))
       request.session = sessionInfo.session;
   }
+
+  _alreadyTrackedNetworkIds: Set<string> = new Set();
 }
 
 class InterceptableRequest {
@@ -614,38 +636,148 @@
   _alreadyContinuedParams: Protocol.Fetch.continueRequestParameters | undefined;
   _fulfilled: boolean = false;
 
-  constructor(session: CRSession, interceptionId: string) {
+  constructor(session: CRSession, interceptionId: string, page: Page | null, networkId: string, sessionManager: CRNetworkManager) {
+    this._page = void 0;
+    this._networkId = void 0;
+    this._sessionManager = void 0;
     this._session = session;
     this._interceptionId = interceptionId;
+    this._page = page;
+    this._networkId = networkId;
+    this._sessionManager = sessionManager;
+    eventsHelper.addEventListener(this._session, 'Fetch.requestPaused', async e => await this._networkRequestIntercepted(e));
   }
 
   async continue(overrides: types.NormalizedContinueOverrides): Promise<void> {
-    this._alreadyContinuedParams = {
-      requestId: this._interceptionId!,
-      url: overrides.url,
-      headers: overrides.headers,
-      method: overrides.method,
-      postData: overrides.postData ? overrides.postData.toString('base64') : undefined
-    };
-    await catchDisallowedErrors(async () => {
-      await this._session.send('Fetch.continueRequest', this._alreadyContinuedParams);
-    });
+    		;
+    		this._alreadyContinuedParams = {
+    			requestId: this._interceptionId,
+    			url: overrides.url,
+    			headers: overrides.headers,
+    			method: overrides.method,
+    			postData: overrides.postData?.toString('base64'),
+    		};
+    		if (overrides.url && (overrides.url === 'http://patchright-init-script-inject.internal/' || overrides.url === 'https://patchright-init-script-inject.internal/')) {
+    			await catchDisallowedErrors(async () => {
+    				this._sessionManager._alreadyTrackedNetworkIds.add(this._networkId);
+    				try {
+    					await this._session._sendMayFail('Fetch.continueRequest', { requestId: this._interceptionId, interceptResponse: true });
+    				} catch (e) {
+    					this._sessionManager._alreadyTrackedNetworkIds.delete(this._networkId);
+    					throw e;
+    				}
+    			});
+    		} else {
+    			await catchDisallowedErrors(async () => {
+    				await this._session._sendMayFail('Fetch.continueRequest', this._alreadyContinuedParams);
+    			});
+    		}
+    	
   }
 
   async fulfill(response: types.NormalizedFulfillResponse) {
-    this._fulfilled = true;
-    const body = response.isBase64 ? response.body : Buffer.from(response.body).toString('base64');
 
-    const responseHeaders = splitSetCookieHeader(response.headers);
-    await catchDisallowedErrors(async () => {
-      await this._session.send('Fetch.fulfillRequest', {
-        requestId: this._interceptionId!,
-        responseCode: response.status,
-        responsePhrase: network.statusText(response.status),
-        responseHeaders,
-        body,
-      });
-    });
+    		const isTextHtml = response.headers.some((header) => header.name.toLowerCase() === "content-type" && header.value.includes("text/html"));
+    		const pageDelegate = this._page?.delegate ?? null;
+    		const initScriptTag = pageDelegate?.initScriptTag ?? "";
+    		const allInjections = pageDelegate
+    			? [...pageDelegate._mainFrameSession._evaluateOnNewDocumentScripts]
+    			: [];
+
+    		if (isTextHtml && allInjections.length && initScriptTag) {
+    			// Decode body if needed
+    			if (response.isBase64) {
+    				response.isBase64 = false;
+    				response.body = Buffer.from(response.body, "base64").toString("utf-8");
+    			}
+
+    			// CSP Detection and Fixing
+    			const cspHeaderNames = ["content-security-policy", "content-security-policy-report-only"];
+    			const extractNonce = (cspValue) => {
+    				const match = cspValue.match(/script-src[^;]*'nonce-([^'"s;]+)'/i);
+    				return match?.[1] ?? null;
+    			};
+    		  let useNonce = false;
+    			let scriptNonce = null;
+
+    			// Fix CSP in headers
+    			for (const header of response.headers) {
+    				if (cspHeaderNames.includes(header.name.toLowerCase())) {
+    					const originalCsp = header.value ?? "";
+    					// Extract nonce if present
+    					const nonce = !useNonce && extractNonce(originalCsp);
+    					if (nonce) {
+    						scriptNonce = nonce;
+    						useNonce = true;
+    					}
+
+    					header.value = this._fixCSP(originalCsp, scriptNonce);
+    				}
+    			}
+
+    			// Fix CSP in meta tags
+    			if (typeof response.body === "string" && response.body.length) {
+    				response.body = response.body.replace(
+    					/<meta[^>]*http-equiv=(?:"|')?Content-Security-Policy(?:"|')?[^>]*>/gi,
+    					(match) => {
+    						const contentMatch = match.match(/content=(?:"|')([^"']*)(?:"|')/i);
+    						if (!contentMatch)
+    							return match;
+
+    						let originalCsp = contentMatch[1];
+    						// Decode HTML entities
+    						originalCsp = originalCsp
+    							.replace(/&amp;/g, '&')  // Must be first!
+    							.replace(/&lt;/g, '<')
+    							.replace(/&gt;/g, '>')
+    							.replace(/&quot;/g, '"')
+    							.replace(/&#x27;/g, "'")
+    							.replace(/&#x22;/g, '"')
+    							.replace(/&nbsp;/g, ' ')
+    							.replace(/&#(d+);/g, (match, dec) => String.fromCharCode(dec))
+    							.replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+
+    						// Extract nonce if present
+    						const nonce = !useNonce && extractNonce(originalCsp);
+    						if (nonce) {
+    							scriptNonce = nonce;
+    							useNonce = true;
+    						}
+
+    						const fixedCsp = this._fixCSP(originalCsp, scriptNonce);
+    						// Re-encode for HTML
+    						const encodedCsp = fixedCsp.replace(/'/g, '&#x27;').replace(/"/g, '&#x22;');
+    						return match.replace(contentMatch[1], encodedCsp);
+    					}
+    				);
+    			}
+
+    			// Build injection HTML - only use nonce if one was found in existing CSP
+    			const nonceAttr = useNonce ? `nonce="${scriptNonce}"` : '';
+    			let injectionHTML = "";
+    			allInjections.forEach((script) => {
+    				let scriptId = crypto.randomBytes(22).toString("hex");
+    				let scriptSource = script.source ?? script;
+    				injectionHTML += `<script class="${initScriptTag}" ${nonceAttr} id="${scriptId}" type="text/javascript">document.getElementById("${scriptId}")?.remove();${scriptSource}</script>`;
+    			});
+
+    			// Inject at END of <head>
+    			response.body = this._injectIntoHead(response.body, injectionHTML);
+    		}
+
+    		this._fulfilled = true;
+    		const body = response.isBase64 ? response.body : Buffer.from(response.body).toString("base64");
+    		const responseHeaders = splitSetCookieHeader(response.headers);
+    		await catchDisallowedErrors(async () => {
+    			await this._session.send("Fetch.fulfillRequest", {
+    				requestId: response.interceptionId ? response.interceptionId : this._interceptionId,
+    				responseCode: response.status,
+    				responsePhrase: network.statusText(response.status),
+    				responseHeaders,
+    				body
+    			});
+    		});
+    	
   }
 
   async abort(errorCode: string = 'failed') {
@@ -658,6 +790,211 @@
       });
     });
   }
+
+  _fixCSP(csp: string | null, scriptNonce: string | null) {
+
+    		if (!csp || typeof csp !== 'string')
+    			return csp;
+
+    		// Split by semicolons and clean up
+    		const directives = csp.split(';')
+    			.map(d => d.trim())
+    			.filter(Boolean);
+
+    		const fixedDirectives = [];
+    		let hasScriptSrc = false;
+
+    		const addIfMissing = (values: string[], ...items: string[]) => {
+    			for (const item of items)
+    				if (!values.includes(item))
+    					values.push(item);
+    		};
+
+
+    		for (let directive of directives) {
+    			// Improved directive parsing to handle more edge cases
+    			const directiveMatch = directive.match(/^([a-zA-Z-]+)\s+(.*)$/);
+    			if (!directiveMatch) {
+    				fixedDirectives.push(directive);
+    				continue;
+    			}
+
+    			const directiveName = directiveMatch[1].toLowerCase();
+    			const directiveValues = directiveMatch[2].split(/\s+/).filter(Boolean);
+
+    			switch (directiveName) {
+    				case 'script-src':
+    					hasScriptSrc = true;
+
+    					// Add nonce if we have one and it's not already present
+    					if (scriptNonce && !directiveValues.some(v => v.includes(`nonce-${scriptNonce}`)))
+    						directiveValues.push(`'nonce-${scriptNonce}'`);
+
+    					// Add 'unsafe-eval' if not present
+    					addIfMissing(directiveValues, "'unsafe-eval'");
+
+    					// Add unsafe-inline if not present and no nonce is being used
+    					if (!scriptNonce)
+    						addIfMissing(directiveValues, "'unsafe-inline'");
+
+    					// Add wildcard for external scripts if not already present
+    					if (!directiveValues.includes("*") && !directiveValues.includes("'self'") && !directiveValues.some(v => v.includes("https:")))
+    						directiveValues.push("*");
+
+    					fixedDirectives.push(`script-src ${directiveValues.join(' ')}`);
+    					break;
+
+    				case 'style-src':
+    					// Add 'unsafe-inline' for styles if not present
+    					addIfMissing(directiveValues, "'unsafe-inline'");
+    					fixedDirectives.push(`style-src ${directiveValues.join(' ')}`);
+    					break;
+
+    				case 'img-src':
+    				case 'font-src':
+    					// Allow data: URLs for images/fonts if not already allowed
+    					if (!directiveValues.includes('*'))
+    						addIfMissing(directiveValues, 'data:');
+    					fixedDirectives.push(`${directiveName} ${directiveValues.join(' ')}`);
+    					break;
+
+    				case 'connect-src':
+    					// Allow WebSocket connections if not already allowed
+    					if (!directiveValues.some(v => v.includes('ws:') || v.includes('wss:') || v === '*'))
+    						addIfMissing(directiveValues, 'ws:', 'wss:');
+    					fixedDirectives.push(`connect-src ${directiveValues.join(' ')}`);
+    					break;
+
+    				case 'frame-ancestors':
+    					// If completely blocked with 'none', allow 'self' at least
+    					let frameAncestorValues = directiveValues.includes("'none'") ? "'self'" : directiveValues.join(' ');
+    					fixedDirectives.push(`frame-ancestors ${frameAncestorValues}`);
+    					break;
+
+    				default:
+    					// Keep other directives as-is
+    					fixedDirectives.push(directive);
+    			}
+    		}
+
+    		// Add script-src if it doesn't exist (for our injected scripts)
+    		if (!hasScriptSrc) {
+    			fixedDirectives.push(
+    				scriptNonce
+    					? `script-src 'self' 'unsafe-eval' 'nonce-${scriptNonce}' *`
+    					: `script-src 'self' 'unsafe-eval' 'unsafe-inline' *`
+    			);
+    		}
+
+    		return fixedDirectives.join('; ');
+    	
+  }
+
+  _injectIntoHead(body: string, injectionHTML: string) {
+
+    		// Inject at END of <head>
+    		const lower = body.toLowerCase();
+    		const headStartIndex = lower.indexOf("<head");
+
+    		if (headStartIndex !== -1) {
+    			const headStartTagEndIndex = lower.indexOf(">", headStartIndex) + 1;
+    			const headEndTagIndex = lower.indexOf("</head>", headStartIndex);
+
+    			if (headEndTagIndex !== -1) {
+    				// Find the first <script> tag in <head>, skipping HTML comments
+    				const headContent = lower.slice(headStartTagEndIndex, headEndTagIndex);
+
+    				// Look for the first <script> tag in the head content but ignore comments
+    				let firstScriptIndex = -1;
+    				let searchPos = 0;
+
+    				while (searchPos < headContent.length) {
+    					const commentStart = headContent.indexOf("<!--", searchPos);
+    					const scriptStart = headContent.indexOf("<script", searchPos);
+
+    					// No more script tags, inject at the end of head content
+    					if (scriptStart === -1)
+    						break;
+
+    					if (commentStart !== -1 && commentStart < scriptStart) {
+    						const commentEnd = headContent.indexOf("-->", commentStart);
+    						if (commentEnd === -1)
+    							break;
+
+    						// Skip past the comment and keep searching
+    						searchPos = commentEnd + 3;
+    					} else {
+    					  // Found a script tag outside a comment
+    						firstScriptIndex = scriptStart;
+    						break;
+    					}
+    				}
+
+    				const insertAt =
+    					firstScriptIndex !== -1
+    						? headStartTagEndIndex + firstScriptIndex   // Before first <script>
+    						: headEndTagIndex;                   		 // Before </head>
+
+    				return body.slice(0, insertAt) + injectionHTML + body.slice(insertAt);
+    			}
+
+    			// No </head> found — inject right after the opening <head> tag
+    			return body.slice(0, headStartTagEndIndex) + injectionHTML + body.slice(headStartTagEndIndex);
+    		}
+
+    		// No <head> — try after <!DOCTYPE>
+    		const doctypeIndex = lower.indexOf("<!doctype");
+    		if (doctypeIndex === 0) {
+    			const doctypeEnd = body.indexOf(">", doctypeIndex) + 1;
+    			return body.slice(0, doctypeEnd) + injectionHTML + body.slice(doctypeEnd);
+    		}
+
+    		// Try after <html>
+    		const htmlTagIndex = lower.indexOf("<html");
+    		if (htmlTagIndex !== -1) {
+    			const htmlTagEnd = body.indexOf(">", htmlTagIndex) + 1;
+    			return body.slice(0, htmlTagEnd) +  `<head>${injectionHTML}</head>` + body.slice(htmlTagEnd);
+    		}
+
+    		// Last resort — prepend to body
+    		return injectionHTML + body;
+    	
+  }
+
+  async _networkRequestIntercepted(event: Protocol.Fetch.requestPausedPayload) {
+
+    		if (this._networkId != event.networkId || !this._sessionManager._alreadyTrackedNetworkIds.has(event.networkId))
+    			return;
+
+    		const trackedNetworkId = event.networkId;
+    		try {
+    			if (event.resourceType !== 'Document')
+    				return;
+
+    			if (event.responseStatusCode >= 301 && event.responseStatusCode <= 308  || (event.redirectedRequestId && !event.responseStatusCode)) {
+    				await this._session.send('Fetch.continueRequest', { requestId: event.requestId, interceptResponse: true });
+    			} else {
+    				const responseBody = await this._session.send('Fetch.getResponseBody', { requestId: event.requestId });
+    				await this.fulfill({
+    					headers: event.responseHeaders,
+    					isBase64: true,
+    					body: responseBody.body,
+    					status: event.responseStatusCode,
+    					interceptionId: event.requestId,
+    					resourceType: event.resourceType,
+    				});
+    			}
+    		} catch (error) {
+    			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 });
+    			}
+    		} finally {
+    			this._sessionManager._alreadyTrackedNetworkIds.delete(trackedNetworkId);
+    		}
+    	
+  }
 }
 
 // In certain cases, protocol will return error if the request was already canceled
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/chromium/crPage.ts patchright/node_modules/playwright-core/src/server/chromium/crPage.ts
---
+++
@@ -45,7 +45,7 @@
 import type { Progress } from '../progress';
 import type * as types from '../types';
 import type * as channels from '@protocol/channels';
-
+import crypto from "crypto";
 
 export type WindowBounds = { top?: number, left?: number, width?: number, height?: number };
 
@@ -96,7 +96,10 @@
     this.updateOffline();
     this.updateExtraHTTPHeaders();
     this.updateHttpCredentials();
-    this.updateRequestInterception();
+    
+    		this._networkManager.setRequestInterception(true);
+    		this.initScriptTag = crypto.randomBytes(20).toString('hex');
+    	
     this._mainFrameSession = new FrameSession(this, client, targetId, null);
     this._sessions.set(targetId, this._mainFrameSession);
     if (opener && !browserContext._options.noDefaultViewport) {
@@ -126,15 +129,15 @@
   }
 
   _sessionForFrame(frame: frames.Frame): FrameSession {
-    // Frame id equals target id.
-    while (!this._sessions.has(frame._id)) {
-      const parent = frame.parentFrame();
-      if (!parent)
-        throw new Error(`Frame has been detached.`);
-      frame = parent;
+      // Frame id equals target id.
+      while (!this._sessions.has(frame._id)) {
+        const parent = frame.parentFrame();
+        if (!parent)
+          throw new Error(`Frame was detached`);
+        frame = parent;
+      }
+      return this._sessions.get(frame._id)!;
     }
-    return this._sessions.get(frame._id)!;
-  }
 
   private _sessionForHandle(handle: dom.ElementHandle): FrameSession {
     const frame = handle._context.frame;
@@ -225,6 +228,7 @@
   }
 
   async addInitScript(initScript: InitScript, world: types.World = 'main'): Promise<void> {
+    this._page.initScripts.push(initScript);
     await this._forAllFrameSessions(frame => frame._evaluateOnNewDocument(initScript, world));
   }
 
@@ -364,6 +368,19 @@
   async setDockTile(image: Buffer): Promise<void> {
     await this._mainFrameSession._client.send('Browser.setDockTile', { image: image.toString('base64') });
   }
+
+  async exposeBinding(binding: PageBinding) {
+
+    		await this._forAllFrameSessions(frame => frame._initBinding(binding));
+    		await Promise.all(this._page.frames().map(frame => frame.evaluateExpression(binding.source).catch(e => {})));
+    	
+  }
+
+  async removeExposedBindings() {
+
+    		await this._forAllFrameSessions(frame => frame._removeExposedBindings());
+    	
+  }
 }
 
 class FrameSession {
@@ -438,6 +455,7 @@
   }
 
   async _initialize(hasUIWindow: boolean) {
+    const pageEnablePromise = this._client.send('Page.enable');
     if (!this._page.isStorageStatePage && hasUIWindow &&
       !this._crPage._browserContext._browser.isClank() &&
       !this._crPage._browserContext._options.noDefaultViewport) {
@@ -451,6 +469,11 @@
     let lifecycleEventsEnabled: Promise<any>;
     if (!this._isMainFrame())
       this._addRendererListeners();
+
+    		let bufferedDialogEvents: any[] | undefined = this._isMainFrame() ? [] : undefined;
+    		if (bufferedDialogEvents)
+    			this._eventListeners.push(eventsHelper.addEventListener(this._client, 'Page.javascriptDialogOpening', (event: any) => bufferedDialogEvents ? bufferedDialogEvents.push(event) : undefined));
+    	
     this._addBrowserListeners();
 
     // Buffer attachedToTarget events until we receive the frame tree.
@@ -460,11 +483,18 @@
     this._bufferedAttachedToTargetEvents = [];
 
     const promises: Promise<any>[] = [
-      this._client.send('Page.enable'),
+      pageEnablePromise,
       this._client.send('Page.getFrameTree').then(({ frameTree }) => {
         if (this._isMainFrame()) {
           this._handleFrameTree(frameTree);
           this._addRendererListeners();
+
+          			// Replay any dialog events that arrived before _addRendererListeners
+          			const pendingDialogEvents = bufferedDialogEvents || [];
+          			bufferedDialogEvents = undefined;
+          			for (const event of pendingDialogEvents)
+          				this._onDialog(event);
+          		
         }
 
         // Now that we have the frame tree, it is possible to insert oopif targets at the right place.
@@ -472,17 +502,6 @@
         this._bufferedAttachedToTargetEvents = undefined;
         for (const event of attachedToTargetEvents)
           this._onAttachedToTarget(event);
-
-        const localFrames = this._isMainFrame() ? this._page.frames() : [this._page.frameManager.frame(this._targetId)!];
-        for (const frame of localFrames) {
-          // Note: frames might be removed before we send these.
-          this._client._sendMayFail('Page.createIsolatedWorld', {
-            frameId: frame._id,
-            grantUniveralAccess: true,
-            worldName: this._crPage.utilityWorldName,
-          });
-        }
-
         const isInitialEmptyPage = this._isMainFrame() && this._page.mainFrame().url() === ':';
         if (isInitialEmptyPage) {
           // Ignore lifecycle events, worlds and bindings for the initial empty page. It is never the final page
@@ -492,13 +511,24 @@
             this._eventListeners.push(eventsHelper.addEventListener(this._client, 'Page.lifecycleEvent', event => this._onLifecycleEvent(event)));
           });
         } 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").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.source).catch(e => {});
+          				for (const source of this._crPage._page.initScripts)
+          					frame.evaluateExpression(source.source).catch(e => {});
+          			}
+          		
           this._firstNonInitialNavigationCommittedFulfill();
           this._eventListeners.push(eventsHelper.addEventListener(this._client, 'Page.lifecycleEvent', event => this._onLifecycleEvent(event)));
         }
       }),
       this._client.send('Log.enable', {}),
       lifecycleEventsEnabled = this._client.send('Page.setLifecycleEventsEnabled', { enabled: true }),
-      this._client.send('Runtime.enable', {}),
       this._client.send('Page.addScriptToEvaluateOnNewDocument', {
         source: '',
         worldName: this._crPage.utilityWorldName,
@@ -509,8 +539,10 @@
     if (!this._page.isStorageStatePage) {
       if (this._crPage._browserContext.needsPlaywrightBinding())
         promises.push(this.exposePlaywrightBinding());
-      if (this._isMainFrame())
-        promises.push(this._client.send('Emulation.setFocusEmulationEnabled', { enabled: true }));
+      
+      		if (this._isMainFrame() && !this._crPage._browserContext._options.focusControl)
+      			promises.push(this._client.send("Emulation.setFocusEmulationEnabled", { enabled: true }));
+      	
       const options = this._crPage._browserContext._options;
       if (options.bypassCSP)
         promises.push(this._client.send('Page.setBypassCSP', { enabled: true }));
@@ -533,12 +565,22 @@
       promises.push(this._updateGeolocation(true));
       promises.push(this._updateEmulateMedia());
       promises.push(this._updateFileChooserInterception(true));
-      for (const initScript of this._crPage._page.allInitScripts())
-        promises.push(this._evaluateOnNewDocument(initScript, 'main', true /* runImmediately */));
+      
+      					  for (const binding of this._crPage._page.allBindings()) promises.push(this._initBinding(binding));
+      					  for (const initScript of this._crPage._browserContext.initScripts) promises.push(this._evaluateOnNewDocument(initScript, 'main'));
+      					  for (const initScript of this._crPage._page.initScripts) promises.push(this._evaluateOnNewDocument(initScript, 'main'));
+      				
     }
-    promises.push(this._client.send('Runtime.runIfWaitingForDebugger'));
+    
+    			if (!(this._crPage._page._pageBindings.size || this._crPage._browserContext._pageBindings.size))
+    				promises.push(this._client.send('Runtime.runIfWaitingForDebugger'));
+    		
     promises.push(this._firstNonInitialNavigationCommittedPromise);
     await Promise.all(promises);
+
+    			if (this._crPage._page._pageBindings.size || this._crPage._browserContext._pageBindings.size)
+    				await this._client.send('Runtime.runIfWaitingForDebugger');
+    		
   }
 
   dispose() {
@@ -562,13 +604,33 @@
     return { newDocumentId: response.loaderId };
   }
 
-  _onLifecycleEvent(event: Protocol.Page.lifecycleEventPayload) {
+  async _onLifecycleEvent(event: Protocol.Page.lifecycleEventPayload) {
     if (this._eventBelongsToStaleFrame(event.frameId))
       return;
     if (event.name === 'load')
       this._page.frameManager.frameLifecycleEvent(event.frameId, 'load');
     else if (event.name === 'DOMContentLoaded')
       this._page.frameManager.frameLifecycleEvent(event.frameId, 'domcontentloaded');
+
+    		// Only do full init script cleanup on load to reduce CDP round-trip pressure.
+    		// Other lifecycle events just get a minimal runIfWaitingForDebugger call.
+    		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
+    		var query = await this._client._sendMayFail("DOM.querySelectorAll", {
+    		  nodeId: document.root.nodeId,
+    		  selector: "[class=" + this._crPage.initScriptTag + "]"
+    		});
+    		if (!query) return
+    		for (const nodeId of query.nodeIds) await this._client._sendMayFail("DOM.removeNode", { nodeId: nodeId });
+    		await this._client._sendMayFail('Runtime.runIfWaitingForDebugger');
+    		// ensuring execution context
+    		try { await this._page.frameManager.frame(this._targetId)._context("utility") } catch { };
+    	
   }
 
   _handleFrameTree(frameTree: Protocol.Page.FrameTree) {
@@ -615,12 +677,33 @@
     this._page.frameManager.frameAttached(frameId, parentFrameId);
   }
 
-  _onFrameNavigated(framePayload: Protocol.Page.Frame, initial: boolean) {
+  async _onFrameNavigated(framePayload: Protocol.Page.Frame, initial: boolean) {
     if (this._eventBelongsToStaleFrame(framePayload.id))
       return;
     this._page.frameManager.frameCommittedNewDocumentNavigation(framePayload.id, framePayload.url + (framePayload.urlFragment || ''), framePayload.name || '', framePayload.loaderId, initial);
     if (!initial)
       this._firstNonInitialNavigationCommittedFulfill();
+
+    		await this._client._sendMayFail('Runtime.runIfWaitingForDebugger');
+    		// patchright: For non-initial navigations, skip DOM cleanup since the document just changed
+    		// and init script tags haven't been re-added yet. The _onLifecycleEvent("load") handler
+    		// will perform cleanup after the page finishes loading.
+    		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", {
+    			nodeId: document.root.nodeId,
+    			selector: "[class=" + this._crPage.initScriptTag + "]"
+    		});
+    		if (!query) return
+    		for (const nodeId of query.nodeIds) await this._client._sendMayFail("DOM.removeNode", { nodeId: nodeId });
+    		await this._client._sendMayFail('Runtime.runIfWaitingForDebugger');
+    		// ensuring execution context
+    		try { await this._page.frameManager.frame(this._targetId)._context("utility") } catch { };
+    	
   }
 
   _onFrameRequestedNavigation(payload: Protocol.Page.frameRequestedNavigationPayload) {
@@ -657,19 +740,33 @@
   }
 
   _onExecutionContextCreated(contextPayload: Protocol.Runtime.ExecutionContextDescription) {
+
+    		for (const name of this._exposedBindingNames)
+    			this._client._sendMayFail('Runtime.addBinding', { name: name, executionContextId: contextPayload.id });
+    	
     const frame = contextPayload.auxData ? this._page.frameManager.frame(contextPayload.auxData.frameId) : null;
+
+    		if (contextPayload.auxData?.type === "worker") throw new Error("ExecutionContext is worker");
+    	
     if (!frame || this._eventBelongsToStaleFrame(frame._id))
       return;
     const delegate = new CRExecutionContext(this._client, contextPayload);
-    let worldName: types.World|null = null;
-    if (contextPayload.auxData && !!contextPayload.auxData.isDefault)
-      worldName = 'main';
-    else if (contextPayload.name === this._crPage.utilityWorldName)
-      worldName = 'utility';
+    let worldName = contextPayload.name;
     const context = new dom.FrameExecutionContext(delegate, frame, worldName);
-    if (worldName)
-      frame._contextCreated(worldName, context);
+    
+    		if (worldName && (worldName === 'main' || worldName === 'utility'))
+    			frame._contextCreated(worldName, context);
+    	
     this._contextIdToContext.set(contextPayload.id, context);
+
+    		for (const source of this._exposedBindingScripts) {
+    			this._client._sendMayFail("Runtime.evaluate", {
+    				expression: source,
+    				contextId: contextPayload.id,
+    				awaitPromise: true,
+    			})
+    		}
+    	
   }
 
   _onExecutionContextDestroyed(executionContextId: number) {
@@ -685,7 +782,7 @@
       this._onExecutionContextDestroyed(contextId);
   }
 
-  _onAttachedToTarget(event: Protocol.Target.attachedToTargetPayload) {
+  async _onAttachedToTarget(event: Protocol.Target.attachedToTargetPayload) {
     if (this._bufferedAttachedToTargetEvents) {
       this._bufferedAttachedToTargetEvents.push(event);
       return;
@@ -727,12 +824,22 @@
     session.once('Runtime.executionContextCreated', async event => {
       worker.createExecutionContext(new CRExecutionContext(session, event.context));
     });
+
+    			var globalThis = await session._sendMayFail('Runtime.evaluate', {
+    				expression: "globalThis",
+    				serializationOptions: { serialization: "idOnly" }
+    			});
+    			if (globalThis && globalThis.result) {
+    				var globalThisObjId = globalThis.result.objectId;
+    				var executionContextId = parseInt(globalThisObjId.split('.')[1], 10);
+    				worker.createExecutionContext(new CRExecutionContext(session, { id: executionContextId }));
+    			}
+    		
     if (this._crPage._browserContext._browser.majorVersion() >= 143)
       session.on('Inspector.workerScriptLoaded', () => worker.workerScriptLoaded());
     else
       worker.workerScriptLoaded();
     // This might fail if the target is closed before we initialize.
-    session._sendMayFail('Runtime.enable');
     // TODO: attribute workers to the right frame.
     this._crPage._networkManager.addSession(session, this._page.frameManager.frame(this._targetId) ?? undefined).catch(() => {});
     session._sendMayFail('Runtime.runIfWaitingForDebugger');
@@ -811,8 +918,10 @@
     const pageOrError = await this._crPage._page.waitForInitializedOrError();
     if (!(pageOrError instanceof Error)) {
       const context = this._contextIdToContext.get(event.executionContextId);
-      if (context)
-        await this._page.onBindingCalled(event.payload, context);
+      
+      		if (context) await this._page.onBindingCalled(event.payload, context);
+      		else await this._page._onBindingCalled(event.payload, (await this._page.mainFrame()._mainContext())) // This might be a bit sketchy but it works for now
+      	
     }
   }
 
@@ -1008,20 +1117,14 @@
   }
 
   async _evaluateOnNewDocument(initScript: InitScript, world: types.World, runImmediately?: boolean): Promise<void> {
-    const worldName = world === 'utility' ? this._crPage.utilityWorldName : undefined;
-    const { identifier } = await this._client.send('Page.addScriptToEvaluateOnNewDocument', { source: initScript.source, worldName, runImmediately });
-    this._initScriptIds.set(initScript, identifier);
+    this._evaluateOnNewDocumentScripts.push(initScript);		
   }
 
   async _removeEvaluatesOnNewDocument(initScripts: InitScript[]): Promise<void> {
-    const ids: string[] = [];
-    for (const script of initScripts) {
-      const id = this._initScriptIds.get(script);
-      if (id)
-        ids.push(id);
-      this._initScriptIds.delete(script);
-    }
-    await Promise.all(ids.map(identifier => this._client.send('Page.removeScriptToEvaluateOnNewDocument', { identifier }).catch(() => {}))); // target can be closed
+
+    			const toRemove = new Set(initScripts);
+    			this._evaluateOnNewDocumentScripts = this._evaluateOnNewDocumentScripts.filter(script => !toRemove.has(script));
+    		
   }
 
   async exposePlaywrightBinding() {
@@ -1126,12 +1229,53 @@
   async _adoptBackendNodeId(backendNodeId: Protocol.DOM.BackendNodeId, to: dom.FrameExecutionContext): Promise<dom.ElementHandle> {
     const result = await this._client._sendMayFail('DOM.resolveNode', {
       backendNodeId,
-      executionContextId: (to.delegate as CRExecutionContext)._contextId,
+      executionContextId: to.delegate._contextId,
     });
     if (!result || result.object.subtype === 'null')
       throw new Error(dom.kUnableToAdoptErrorMessage);
     return createHandle(to, result.object).asElement()!;
   }
+
+  _exposedBindingNames: string[] = [];
+  _evaluateOnNewDocumentScripts: InitScript[] = [];
+  _parsedExecutionContextIds: number[] = [];
+  _exposedBindingScripts: string[] = [];
+
+  async _initBinding(binding = PageBinding) {
+
+    		// Remember this binding so future execution contexts get it in _onExecutionContextCreated.
+    		this._exposedBindingNames.push(binding.name);
+    		this._exposedBindingScripts.push(binding.source);
+
+    		// Install binding in all existing execution contexts.
+    		const contextIds = Array.from(this._contextIdToContext.keys());
+    		await Promise.all([
+    			this._client._sendMayFail('Runtime.addBinding', { name: binding.name }),
+    			...contextIds.map(executionContextId => this._client._sendMayFail('Runtime.addBinding', { name: binding.name, executionContextId })),
+    		]);
+
+    		// Evaluate binding bootstrap in all existing execution contexts.
+    		const evaluationPromises = contextIds.map(contextId =>
+    			this._client._sendMayFail('Runtime.evaluate', {
+    				expression: binding.source,
+    				contextId,
+    				awaitPromise: true,
+    			}).catch(e => { }),
+    		);
+    		await Promise.all(evaluationPromises);
+    	
+  }
+
+  async _removeExposedBindings() {
+
+    		const toRetain: string[] = [];
+    		const toRemove: string[] = [];
+    		for (const name of this._exposedBindingNames)
+    			(name.startsWith('__pw_') ? toRetain : toRemove).push(name);
+    		this._exposedBindingNames = toRetain;
+    		await Promise.all(toRemove.map(name => this._client.send('Runtime.removeBinding', { name })));
+    	
+  }
 }
 
 async function emulateLocale(session: CRSession, locale: string) {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/chromium/crServiceWorker.ts patchright/node_modules/playwright-core/src/server/chromium/crServiceWorker.ts
---
+++
@@ -63,13 +63,23 @@
       const message = new ConsoleMessage(null, this, event.type, undefined, args, toConsoleMessageLocation(event.stackTrace), event.timestamp);
       this.browserContext.emit(BrowserContext.Events.Console, message);
     });
-
-    session.send('Runtime.enable', {}).catch(e => {});
     session.send('Runtime.runIfWaitingForDebugger').catch(e => {});
     session.on('Inspector.targetReloadedAfterCrash', () => {
       // Resume service worker after restart.
       session._sendMayFail('Runtime.runIfWaitingForDebugger', {});
     });
+
+    		session._sendMayFail("Runtime.evaluate", {
+    			expression: "globalThis",
+    			serializationOptions: { serialization: "idOnly" }
+    		}).then(globalThis => {
+    			if (globalThis && globalThis.result) {
+    				var globalThisObjId = globalThis.result.objectId;
+    				var executionContextId = parseInt(globalThisObjId.split(".")[1], 10);
+    				this.createExecutionContext(new CRExecutionContext(session, { id: executionContextId }));
+    			}
+    		});
+    	
   }
 
   override didClose() {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/clock.ts patchright/node_modules/playwright-core/src/server/clock.ts
---
+++
@@ -106,6 +106,15 @@
   }
 
   private async _evaluateInFrames(script: string) {
+
+    			// Dont ask me why this works
+    			const frames = this._browserContext.pages().flatMap((page) => page.frames());
+    			await Promise.all(frames.map(async (frame) => {
+    				try {
+    					await frame.evaluateExpression("");
+    				} catch {}
+    			}));
+    		
     await this._browserContext.safeNonStallingEvaluateInAllFrames(script, 'main', { throwOnJSErrors: true });
   }
 }
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/dispatchers/browserContextDispatcher.ts patchright/node_modules/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
---
+++
@@ -124,12 +124,12 @@
         });
       }
     });
-    this._dialogHandler = dialog => {
-      if (!this._shouldDispatchEvent(dialog.page(), 'dialog'))
-        return false;
-      this._dispatchEvent('dialog', { dialog: new DialogDispatcher(this, dialog) });
-      return true;
-    };
+    
+    		this._dialogHandler = dialog => {
+    			this._dispatchEvent('dialog', { dialog: new DialogDispatcher(this, dialog) });
+    			return true;
+    		};
+    	
     context.dialogManager.addDialogHandler(this._dialogHandler);
 
     if (context._browser.options.name === 'chromium' && this._object._browser instanceof CRBrowser) {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/dispatchers/frameDispatcher.ts patchright/node_modules/playwright-core/src/server/dispatchers/frameDispatcher.ts
---
+++
@@ -84,11 +84,36 @@
   }
 
   async evaluateExpression(params: channels.FrameEvaluateExpressionParams, progress: Progress): Promise<channels.FrameEvaluateExpressionResult> {
-    return { value: serializeResult(await progress.race(this._frame.evaluateExpression(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)))) };
+
+    		return {
+    			value: serializeResult(
+    				await progress.race(
+    					this._frame.evaluateExpression(
+    						params.expression,
+    						{ isFunction: params.isFunction, world: params.isolatedContext ? 'utility': 'main' },
+    						parseArgument(params.arg)
+    					)
+    				)
+    			)
+    		};
+    	
   }
 
   async evaluateExpressionHandle(params: channels.FrameEvaluateExpressionHandleParams, progress: Progress): Promise<channels.FrameEvaluateExpressionHandleResult> {
-    return { handle: ElementHandleDispatcher.fromJSOrElementHandle(this, await progress.race(this._frame.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)))) };
+
+    		return {
+    			handle: ElementHandleDispatcher.fromJSOrElementHandle(
+    				this,
+    				await progress.race(
+    					this._frame.evaluateExpressionHandle(
+    						params.expression,
+    						{ isFunction: params.isFunction, world: params.isolatedContext ? 'utility': 'main' },
+    						parseArgument(params.arg)
+    					)
+    				)
+    			)
+    		};
+    	
   }
 
   async waitForSelector(params: channels.FrameWaitForSelectorParams, progress: Progress): Promise<channels.FrameWaitForSelectorResult> {
@@ -104,7 +129,20 @@
   }
 
   async evalOnSelectorAll(params: channels.FrameEvalOnSelectorAllParams, progress: Progress): Promise<channels.FrameEvalOnSelectorAllResult> {
-    return { value: serializeResult(await progress.race(this._frame.evalOnSelectorAll(params.selector, params.expression, params.isFunction, parseArgument(params.arg)))) };
+
+    		return {
+    			value: serializeResult(
+    				await this._frame.evalOnSelectorAll(
+    					params.selector,
+    					params.expression,
+    					params.isFunction,
+    					parseArgument(params.arg),
+    					null,
+    					params.isolatedContext
+    				)
+    			)
+    		};
+    	
   }
 
   async querySelector(params: channels.FrameQuerySelectorParams, progress: Progress): Promise<channels.FrameQuerySelectorResult> {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/dispatchers/jsHandleDispatcher.ts patchright/node_modules/playwright-core/src/server/dispatchers/jsHandleDispatcher.ts
---
+++
@@ -43,12 +43,12 @@
   }
 
   async evaluateExpression(params: channels.JSHandleEvaluateExpressionParams, progress: Progress): Promise<channels.JSHandleEvaluateExpressionResult> {
-    const jsHandle = await progress.race(this._object.evaluateExpression(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)));
+    const jsHandle = await progress.race(this._object.evaluateExpression(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg), params.isolatedContext));
     return { value: serializeResult(jsHandle) };
   }
 
   async evaluateExpressionHandle(params: channels.JSHandleEvaluateExpressionHandleParams, progress: Progress): Promise<channels.JSHandleEvaluateExpressionHandleResult> {
-    const jsHandle = await progress.race(this._object.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)));
+    const jsHandle = await progress.race(this._object.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg), params.isolatedContext));
     // If "jsHandle" is an ElementHandle, it belongs to the same frame as "this".
     return { handle: ElementHandleDispatcher.fromJSOrElementHandle(this.parentScope() as FrameDispatcher, jsHandle) };
   }
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/frameSelectors.ts patchright/node_modules/playwright-core/src/server/frameSelectors.ts
---
+++
@@ -23,7 +23,10 @@
 import type { JSHandle } from './javascript';
 import type * as types from './types';
 import type { ParsedSelector } from '../utils/isomorphic/selectorParser';
-
+import { ElementHandle } from "./dom";
+import type { CRSession } from "./chromium/crConnection";
+import type { Progress } from "./progress";
+import type { Protocol } from "./chromium/protocol";
 
 export type SelectorInfo = {
   parsed: ParsedSelector,
@@ -65,8 +68,8 @@
     return adoptIfNeeded(elementHandle, await resolved.frame._mainContext());
   }
 
-  async queryArrayInMainWorld(selector: string, scope?: ElementHandle): Promise<JSHandle<Element[]>> {
-    const resolved = await this.resolveInjectedForSelector(selector, { mainWorld: true }, scope);
+  async queryArrayInMainWorld(selector: string, scope?: ElementHandle, isolatedContext?: boolean): Promise<JSHandle<Element[]>> {
+    const resolved = await this.resolveInjectedForSelector(selector, { mainWorld: !isolatedContext }, scope);
     // Be careful, |this.frame| can be different from |resolved.frame|.
     if (!resolved)
       throw new Error(`Failed to find frame for selector "${selector}"`);
@@ -156,9 +159,26 @@
           throw injected.createStacklessError(`Selector "${selectorString}" resolved to ${injected.previewNode(element)}, <iframe> was expected`);
         return element;
       }, { info, scope: i === 0 ? scope : undefined, selectorString: stringifySelector(info.parsed) });
-      const element = handle.asElement() as ElementHandle<Element> | null;
-      if (!element)
-        return null;
+      let element = handle.asElement() as ElementHandle<Element> | null;
+      
+      		if (!element) {
+      			try {
+      				var client = frame._page.delegate._sessionForFrame(frame)._client;
+      			} catch (e) {
+      				var client = frame._page.delegate._mainFrameSession._client;
+      			}
+      			var mainContext = await frame._context("main");
+      			const documentNode = await client.send("Runtime.evaluate", {
+      				expression: "document",
+      				serializationOptions: { serialization: "idOnly" },
+      				contextId: mainContext.delegate._contextId
+      			});
+      			const documentScope = new ElementHandle(mainContext, documentNode.result.objectId);
+      				var check = await this._customFindFramesByParsed(injectedScript, client, mainContext, documentScope, undefined, info.parsed);
+      			if (check.length === 0) return null;
+      			element = check[0];
+      		}
+      	
       const maybeFrame = await frame._page.delegate.getContentFrame(element);
       element.dispose();
       if (!maybeFrame)
@@ -179,9 +199,194 @@
     if (!resolved)
       return;
     const context = await resolved.frame._context(options?.mainWorld ? 'main' : resolved.info.world);
+    if (!context) throw new Error("Frame was detached");
     const injected = await context.injectedScript();
     return { injected, info: resolved.info, frame: resolved.frame, scope: resolved.scope };
   }
+
+  async _customFindFramesByParsed(resolved: JSHandle<InjectedScript>, client: CRSession, context: FrameExecutionContext, documentScope: ElementHandle, progress: Progress | undefined, parsed: ParsedSelector) {
+
+    		var parsedEdits = { ...parsed };
+    		const callId = progress?.metadata.id;
+    		// Note: We start scoping at document level
+    		var currentScopingElements = [documentScope];
+
+    		for (const part of [...parsed.parts]) {
+    			parsedEdits.parts = [part];
+    			var elements = [];
+
+    			if (part.name === "nth") {
+    				const partNth = Number(part.body);
+    				// Check if any Elements are currently scoped, else return empty array to continue polling
+    				if (currentScopingElements.length == 0)
+    					return [];
+
+    				if (partNth > currentScopingElements.length-1 || partNth < -(currentScopingElements.length-1)) {
+    					if (parsed.capture !== undefined)
+    						throw new Error("Can't query n-th element in a request with the capture.");
+    					return [];
+    				}
+    				currentScopingElements = [currentScopingElements.at(partNth)];
+    				continue;
+    			} else if (part.name === "internal:or") {
+    				var orredElements = await this._customFindFramesByParsed(resolved, client, context, documentScope, progress, part.body.parsed);
+    				elements = [...currentScopingElements, ...orredElements];
+    			} else if (part.name == "internal:and") {
+    				var andedElements = await this._customFindFramesByParsed(resolved, client, context, documentScope, progress, part.body.parsed);
+    				const backendNodeIds = new Set(andedElements.map(elem => elem.backendNodeId));
+    				elements = currentScopingElements.filter(elem => backendNodeIds.has(elem.backendNodeId));
+    			} else {
+    				for (const scope of currentScopingElements) {
+    					const describedScope = await client.send("DOM.describeNode", {
+    						objectId: scope._objectId,
+    						depth: -1,
+    						pierce: true
+    					});
+
+    					let findClosedShadowRoots = function(node, results = []) {
+    						if (!node || typeof node !== "object") return results;
+    						if (node.shadowRoots && Array.isArray(node.shadowRoots)) {
+    							for (const shadowRoot of node.shadowRoots) {
+    								if (shadowRoot.shadowRootType === "closed" && shadowRoot.backendNodeId) {
+    									results.push(shadowRoot.backendNodeId);
+    								}
+    								findClosedShadowRoots(shadowRoot, results);
+    							}
+    						}
+    						if (node.nodeName !== "IFRAME" && node.children && Array.isArray(node.children)) {
+    							for (const child of node.children) {
+    								findClosedShadowRoots(child, results);
+    							}
+    						}
+    						return results;
+    					};
+    					var shadowRootBackendIds = findClosedShadowRoots(describedScope.node);
+
+    					const shadowRoots = await Promise.all(
+    						shadowRootBackendIds.map(async backendNodeId => {
+    							const resolved = await client.send("DOM.resolveNode", {
+    								backendNodeId,
+    								contextId: context.delegate._contextId,
+    							});
+    							return new ElementHandle(context, resolved.object.objectId);
+    						})
+    					);
+
+    					// Elements Queryed in the "current round"
+    					const queryGroups: { handles: any; parentNode: any }[] = [];
+    					for (var shadowRoot of shadowRoots) {
+    						const shadowHandles = await shadowRoot.evaluateHandleInUtility(
+    							([injected, node, { parsed, callId }]) => {
+    							 	const elements = injected.querySelectorAll(parsed, node);
+    								if (callId)
+    									injected.markTargetElements(new Set(elements), callId);
+    								return elements;
+    							}, {
+    								parsed: parsedEdits,
+    								callId
+    							}
+    						);
+    						queryGroups.push({ handles: shadowHandles, parentNode: shadowRoot });
+    					}
+
+    					// Document Root Elements (not in CSR)
+    					const rootHandles = await scope.evaluateHandleInUtility(
+    						([injected, node, { parsed, callId }]) => {
+    						 	const elements = injected.querySelectorAll(parsed, node);
+    							if (callId)
+    								injected.markTargetElements(new Set(elements), callId);
+    							return elements;
+    						}, {
+    							parsed: parsedEdits,
+    							callId
+    						}
+    					);
+    					queryGroups.push({ handles: rootHandles, parentNode: scope });
+
+    					// Querying and Sorting the elements by their backendNodeId
+    					for (const { handles, parentNode } of queryGroups) {
+    						const handlesAmount = await (await handles.getProperty("length")).jsonValue();
+    						for (var i = 0; i < handlesAmount; i++) {
+    						  if (parentNode instanceof ElementHandle) {
+    								var element = await parentNode.evaluateHandleInUtility(
+    									([injected, node, { i, handles: elems }]) => elems[i],
+    									{ i, handles }
+    								);
+    							} else {
+    								var element = await parentNode.evaluateHandle(
+    									(injected, { i, handles: elems }) => elems[i],
+    									{ i, handles }
+    								);
+    							}
+
+    							// For other Functions/Utilities
+    							element.parentNode = parentNode;
+    							const resolvedElement = await client.send("DOM.describeNode", { objectId: element._objectId, depth: -1 });
+    							element.backendNodeId = resolvedElement.node.backendNodeId;
+    							element.nodePosition = await this._findElementPositionInDomTree(element, describedScope.node, context, "");
+    							elements.push(element);
+    						}
+    					}
+    				}
+    			}
+
+    			// Sorting elements by their nodePosition, which is a index to the Element in the DOM tree
+    			const getParts = (pos) => (pos || '').split('.').filter(Boolean).map(Number);
+    			elements.sort((a, b) => {
+    				const partsA = getParts(a.nodePosition);
+    				const partsB = getParts(b.nodePosition);
+
+    				for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    					const diff = (partsA[i] ?? -1) - (partsB[i] ?? -1);
+    					if (diff !== 0) return diff;
+    				}
+    				return 0;
+    			});
+
+    			// Remove duplicates by backendNodeId, keeping the first occurrence
+    			currentScopingElements = Array.from(
+    				new Map(elements.map(e => [e.backendNodeId, e])).values()
+    			);
+    		}
+
+    		return currentScopingElements;
+    	
+  }
+
+  async _findElementPositionInDomTree(element: { backendNodeId: number }, queryingElement: Protocol.DOM.Node, context: FrameExecutionContext, currentIndex: string) {
+
+    		// Get Element Position in DOM Tree by Indexing it via their children indexes, like a search tree index
+    		// Check if backendNodeId matches, if so, return currentIndex
+    		if (element.backendNodeId === queryingElement.backendNodeId)
+    			return currentIndex;
+
+    		// Iterating through children of queryingElement
+    		for (const [childrenNodeIndex, child] of (queryingElement.children || []).entries()) {
+    			// Further querying the child recursively and appending the children index to the currentIndex
+    			const childIndex = await this._findElementPositionInDomTree(element, child, context, currentIndex + "." + childrenNodeIndex.toString());
+    			if (childIndex !== null) return childIndex;
+    		}
+
+    		for (const shadowRoot of queryingElement.shadowRoots || []) {
+    			// For CSRs, we dont have to append its index because patchright treats CSRs like they dont exist
+    			if (shadowRoot.shadowRootType === "closed" && shadowRoot.backendNodeId) {
+    				// Resolve the CDP client for the current context so closed shadow roots can be traversed safely.
+    				const client = context.frame._page.delegate._sessionForFrame(context.frame)._client;
+    				const describedShadowRoot = await client.send("DOM.describeNode", { backendNodeId: shadowRoot.backendNodeId, depth: -1, pierce: true });
+    				if (describedShadowRoot && describedShadowRoot.node) {
+    					const childIndex = await this._findElementPositionInDomTree(element, describedShadowRoot.node, context, currentIndex);
+    					if (childIndex !== null) return childIndex;
+    				}
+    			}
+    			// Traverse into shadow root children (open and closed) to properly position elements inside shadow DOMs
+    			for (const [shadowChildIndex, shadowChild] of (shadowRoot.children || []).entries()) {
+    				const childIndex = await this._findElementPositionInDomTree(element, shadowChild, context, currentIndex + "." + shadowChildIndex.toString());
+    				if (childIndex !== null) return childIndex;
+    			}
+    		}
+    		return null;
+    	
+  }
 }
 
 async function adoptIfNeeded<T extends Node>(handle: ElementHandle<T>, context: FrameExecutionContext): Promise<ElementHandle<T>> {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/frames.ts patchright/node_modules/playwright-core/src/server/frames.ts
---
+++
@@ -42,6 +42,10 @@
 import type { RegisteredListener } from './utils/eventsHelper';
 import type { ParsedSelector } from '../utils/isomorphic/selectorParser';
 import type * as channels from '@protocol/channels';
+import { CRExecutionContext } from "./chromium/crExecutionContext";
+import { FrameExecutionContext } from "./dom";
+import type { CRSession } from "./chromium/crConnection";
+import crypto from "crypto";
 
 type ContextData = {
   contextPromise: ManualPromise<dom.FrameExecutionContext | { destroyedReason: string }>;
@@ -239,6 +243,9 @@
       // No pending - just commit a new document.
       frame._currentDocument = { documentId, request: undefined };
     }
+    frame._iframeWorld = undefined;
+    frame._mainWorld = undefined;
+    frame._isolatedWorld = undefined;
 
     frame._onClearLifecycle();
     const navigationEvent: NavigationEvent = { url, name, newDocument: frame._currentDocument, isPublic: true };
@@ -572,12 +579,15 @@
   }
 
   nonStallingEvaluateInExistingContext(expression: string, world: types.World): Promise<any> {
-    return this.raceAgainstEvaluationStallingEvents(() => {
-      const context = this._contextData.get(world)?.context;
-      if (!context)
-        throw new Error('Frame does not yet have the execution context');
-      return context.evaluateExpression(expression, { isFunction: false });
-    });
+
+    		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');
+    			return context.evaluateExpression(expression, { isFunction: false });
+    		});
+    	
   }
 
   _recalculateNetworkIdle(frameThatAllowsRemovingNetworkIdle?: Frame) {
@@ -722,12 +732,69 @@
     return this._page.delegate.getFrameElement(this);
   }
 
-  _context(world: types.World): Promise<dom.FrameExecutionContext> {
-    return this._contextData.get(world)!.contextPromise.then(contextOrDestroyedReason => {
-      if (contextOrDestroyedReason instanceof js.ExecutionContext)
-        return contextOrDestroyedReason;
-      throw new Error(contextOrDestroyedReason.destroyedReason);
-    });
+  async _context(world: types.World): Promise<dom.FrameExecutionContext> {
+
+    		if (this.isDetached())
+    			throw new Error('Frame was detached');
+
+    		let client;
+    		try {
+    			client = this._page.delegate._sessionForFrame(this)._client;
+    		} catch (e) {
+    			client = this._page.delegate._mainFrameSession._client;
+    		}
+
+    		var iframeExecutionContextId = await this._getFrameMainFrameContextId(client);
+    		const isMainFrame = this === this._page.mainFrame();
+    		const session = this._page.delegate._sessionForFrame(this);
+
+    		const registerContext = (executionContextId: number, worldName: string) => {
+    			const crContext = new CRExecutionContext(client, { id: executionContextId }, this._id);
+    			const frameContext = new FrameExecutionContext(crContext, this, worldName);
+    			session._onExecutionContextCreated({
+    				id: executionContextId,
+    				origin: worldName,
+    				name: worldName,
+    				auxData: { isDefault: isMainFrame, type: 'isolated', frameId: this._id },
+    			});
+    			return frameContext;
+    		};
+
+    		if (world === "main") {
+    			// Iframe Only
+    			if (!isMainFrame && iframeExecutionContextId && this._iframeWorld === undefined) {
+    				this._iframeWorld = registerContext(iframeExecutionContextId, world);
+    			} else if (this._mainWorld === undefined) {
+    				const globalThis = await client._sendMayFail('Runtime.evaluate', {
+    					expression: "globalThis",
+    					serializationOptions: { serialization: "idOnly" },
+    				});
+    				if (!globalThis) {
+    					if (this.isDetached()) throw new Error('Frame was detached');
+    					return;
+    				}
+    				const executionContextId = parseInt(globalThis.result.objectId.split('.')[1], 10);
+    				this._mainWorld = registerContext(executionContextId, world);
+    			}
+    		}
+
+    		if (world !== "main" && this._isolatedWorld === undefined) {
+    			const result = await client._sendMayFail('Page.createIsolatedWorld', {
+    				frameId: this._id, grantUniveralAccess: true, worldName: world,
+    			});
+    			if (!result) {
+    				if (this.isDetached()) throw new Error("Frame was detached");
+    				return;
+    			}
+    			this._isolatedWorld = registerContext(result.executionContextId, "utility");
+    		}
+
+    		if (world !== "main")
+    			return this._isolatedWorld;
+    		if (!isMainFrame && this._iframeWorld)
+    			return this._iframeWorld;
+    		return this._mainWorld;
+    	
   }
 
   _mainContext(): Promise<dom.FrameExecutionContext> {
@@ -743,107 +810,168 @@
   }
 
   async evaluateExpression(expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<any> {
-    const context = await this._context(options.world ?? 'main');
-    const value = await context.evaluateExpression(expression, options, arg);
-    return value;
+
+    		const context = await this._detachedScope.race(this._context(options.world ?? "main"));
+    		return await this._detachedScope.race(context.evaluateExpression(expression, options, arg));
+    	
   }
 
   async evaluateExpressionHandle(expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<js.JSHandle<any>> {
-    const context = await this._context(options.world ?? 'main');
-    const value = await context.evaluateExpressionHandle(expression, options, arg);
-    return value;
+
+    		const context = await this._detachedScope.race(this._context(options.world ?? "utility"));
+    		return await this._detachedScope.race(context.evaluateExpressionHandle(expression, options, arg));
+    	
   }
 
   async querySelector(selector: string, options: types.StrictOptions): Promise<dom.ElementHandle<Element> | null> {
-    this.apiLog(`    finding element using the selector "${selector}"`);
-    return this.selectors.query(selector, options);
+
+    		return this.querySelectorAll(selector, options).then((handles) => {
+    			if (handles.length === 0)
+    				return null;
+    			if (handles.length > 1 && options?.strict)
+    				throw new Error(`Strict mode: expected one element matching selector "${selector}", found ${handles.length}`);
+    			return handles[0];
+    		});
+    	
   }
 
   async waitForSelector(progress: Progress, selector: string, performActionPreChecksAndLog: boolean, options: types.WaitForElementOptions, scope?: dom.ElementHandle): Promise<dom.ElementHandle<Element> | null> {
-    if ((options as any).visibility)
-      throw new Error('options.visibility is not supported, did you mean options.state?');
-    if ((options as any).waitFor && (options as any).waitFor !== 'visible')
-      throw new Error('options.waitFor is not supported, did you mean options.state?');
-    const { state = 'visible' } = options;
-    if (!['attached', 'detached', 'visible', 'hidden'].includes(state))
-      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.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-      if (performActionPreChecksAndLog)
-        await this._page.performActionPreChecks(progress);
 
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
-      if (!resolved) {
-        if (state === 'hidden' || state === 'detached')
-          return null;
-        return continuePolling;
-      }
-      const result = await progress.race(resolved.injected.evaluateHandle((injected, { info, root }) => {
-        if (root && !root.isConnected)
-          throw injected.createStacklessError('Element is not attached to the DOM');
-        const elements = injected.querySelectorAll(info.parsed, root || document);
-        const element: Element | undefined  = elements[0];
-        const visible = element ? injected.utils.isElementVisible(element) : false;
-        let log = '';
-        if (elements.length > 1) {
-          if (info.strict)
-            throw injected.strictModeViolationError(info.parsed, elements);
-          log = `  locator resolved to ${elements.length} elements. Proceeding with the first one: ${injected.previewNode(elements[0])}`;
-        } else if (element) {
-          log = `  locator resolved to ${visible ? 'visible' : 'hidden'} ${injected.previewNode(element)}`;
-        }
-        injected.checkDeprecatedSelectorUsage(info.parsed, elements);
-        return { log, element, visible, attached: !!element };
-      }, { info: resolved.info, root: resolved.frame === this ? scope : undefined }));
-      const { log, visible, attached } = await progress.race(result.evaluate(r => ({ log: r.log, visible: r.visible, attached: r.attached })));
-      if (log)
-        progress.log(log);
-      const success = { attached, detached: !attached, visible, hidden: !visible }[state];
-      if (!success) {
-        result.dispose();
-        return continuePolling;
-      }
-      if (options.omitReturnValue) {
-        result.dispose();
-        return null;
-      }
-      const element = state === 'attached' || state === 'visible' ? await progress.race(result.evaluateHandle(r => r.element)) : null;
-      result.dispose();
-      if (!element)
-        return null;
-      if ((options as any).__testHookBeforeAdoptNode)
-        await progress.race((options as any).__testHookBeforeAdoptNode());
-      try {
-        const mainContext = await progress.race(resolved.frame._mainContext());
-        return await progress.race(element._adoptTo(mainContext));
-      } catch (e) {
-        return continuePolling;
-      }
-    });
-    return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
+    		if ((options as any).visibility)
+    			throw new Error('options.visibility is not supported, did you mean options.state?');
+    		if ((options as any).waitFor && (options as any).waitFor !== 'visible')
+    			throw new Error('options.waitFor is not supported, did you mean options.state?');
+
+    		const { state = 'visible' } = options;
+    		if (!['attached', 'detached', 'visible', 'hidden'].includes(state))
+    			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, 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) {
+    				if (handle.parentNode instanceof dom.ElementHandle) {
+    					visible = await handle.parentNode.evaluateInUtility(([injected, node, { handle }]) => {
+    						return handle ? injected.utils.isElementVisible(handle) : false;
+    					}, { handle });
+    				} else {
+    					visible = await handle.parentNode.evaluate((injected, { handle }) => {
+    						return handle ? injected.utils.isElementVisible(handle) : false;
+    					}, { handle });
+    				}
+    			}
+
+    			const success = {
+    				attached,
+    				detached: !attached,
+    				visible,
+    				hidden: !visible
+    			}[state];
+    			if (!success) return "internal:continuepolling";
+    			if (options.omitReturnValue) return null;
+
+    			const element = state === 'attached' || state === 'visible' ? handle : null;
+    			if (!element) return null;
+    			if (options.__testHookBeforeAdoptNode) await options.__testHookBeforeAdoptNode();
+    			try {
+    				return element;
+    			} catch (e) {
+    				return "internal:continuepolling";
+    			}
+    		}, "returnOnNotResolved");
+
+    		const resultPromise = scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
+    		return resultPromise.catch(e => {
+    			if (this.isDetached() && (e as any)?.message?.includes('Execution context was destroyed'))
+    				throw new Error('Frame was detached');
+    			throw e;
+    		});
+    	
   }
 
   async dispatchEvent(progress: Progress, selector: string, type: string, eventInit: Object = {}, options: types.QueryOnSelectorOptions, scope?: dom.ElementHandle): Promise<void> {
-    await this._callOnElementOnceMatches(progress, selector, (injectedScript, element, data) => {
-      injectedScript.dispatchEvent(element, data.type, data.eventInit);
-    }, { type, eventInit }, { mainWorld: true, ...options }, scope);
+
+    		const eventInitHandles: js.JSHandle[] = [];
+    		const visited = new WeakSet();
+    		const collectHandles = (value: any) => {
+    			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 handlesFrame = eventInitHandles[0]?._context?.frame;
+    		const allHandlesFromSameFrame = eventInitHandles.length > 0 && eventInitHandles.every(handle => handle._context?.frame === handlesFrame);
+    		const canRetryInSecondaryContext = allHandlesFromSameFrame && (handlesFrame !== this || !selector.includes("internal:control=enter-frame"));
+    		const callback = (injectedScript, element, data) => {
+    			injectedScript.dispatchEvent(element, data.type, data.eventInit);
+    		};
+    		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: string, strict: boolean, expression: string, isFunction: boolean | undefined, arg: any, scope?: dom.ElementHandle): Promise<any> {
-    const handle = await this.selectors.query(selector, { strict }, scope);
-    if (!handle)
-      throw new Error(`Failed to find element matching selector "${selector}"`);
-    const result = await handle.evaluateExpression(expression, { isFunction }, arg);
-    handle.dispose();
-    return result;
+
+    		const handle = await this.selectors.query(selector, { strict }, scope);
+    		if (!handle)
+    			throw new Error('Failed to find element matching selector "' + selector + '"');
+    		const result = await handle.evaluateExpression(expression, { isFunction }, arg, true);
+    		handle.dispose();
+    		return result;
+    	
   }
 
-  async evalOnSelectorAll(selector: string, expression: string, isFunction: boolean | undefined, arg: any, scope?: dom.ElementHandle): Promise<any> {
-    const arrayHandle = await this.selectors.queryArrayInMainWorld(selector, scope);
-    const result = await arrayHandle.evaluateExpression(expression, { isFunction }, arg);
-    arrayHandle.dispose();
-    return result;
+  async evalOnSelectorAll(selector: string, expression: string, isFunction: boolean | undefined, arg: any, scope?: dom.ElementHandle, isolatedContext?: boolean): Promise<any> {
+
+    		const maxAttempts = 3;
+    		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    			try {
+    				isolatedContext = this.selectors._parseSelector(selector, { strict: false }).world !== "main" && isolatedContext;
+    				const arrayHandle = await this.selectors.queryArrayInMainWorld(selector, scope, isolatedContext);
+    				const result = await arrayHandle.evaluateExpression(expression, { isFunction }, arg, isolatedContext);
+    				arrayHandle.dispose();
+    				return result;
+    			} catch (e) {
+    				// Retry only on specific context mismatch errors, and only a bounded number of times.
+    				if ("JSHandles can be evaluated only in the context they were created!" !== e.message || attempt === maxAttempts) throw e;
+    				await new Promise(resolve => setTimeout(resolve, 50 * attempt));
+    			}
+    		}
+    	
   }
 
   async maskSelectors(selectors: ParsedSelector[], color: string): Promise<void> {
@@ -855,17 +983,34 @@
   }
 
   async querySelectorAll(selector: string): Promise<dom.ElementHandle<Element>[]> {
-    return this.selectors.queryAll(selector);
+
+    		const metadata = { internal: false, log: [], method: "querySelectorAll" };
+    		const progress = {
+    			log: message => metadata.log.push(message),
+    			metadata,
+    			race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
+    		}
+    		return await this._retryWithoutProgress(progress, selector, {strict: null, performActionPreChecks: false}, async (result) => {
+    			if (!result || !result[0]) return [];
+    			return Array.isArray(result[1]) ? result[1] : [];
+    		}, 'returnAll', null);
+    	
   }
 
   async queryCount(selector: string, options: any): Promise<number> {
-    try {
-      return await this.selectors.queryCount(selector, options);
-    } catch (e) {
-      if (this.isNonRetriableError(e))
-        throw e;
-      return 0;
-    }
+
+    		const metadata = { internal: false, log: [], method: "queryCount" };
+    		const progress = {
+    			log: message => metadata.log.push(message),
+    			metadata,
+    			race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
+    		}
+    		return await this._retryWithoutProgress(progress, selector, {strict: null, performActionPreChecks: false }, async (result) => {
+    			if (!result || !result[0])
+    				return 0;
+    			return Array.isArray(result[1]) ? result[1].length : 0;
+    		}, 'returnAll', null);
+    	
   }
 
   async content(): Promise<string> {
@@ -887,29 +1032,23 @@
   }
 
   async setContent(progress: Progress, html: string, options: types.NavigateOptions): Promise<void> {
-    const tag = `--playwright--set--content--${this._id}--${++this._setContentCounter}--`;
-    await this.raceNavigationAction(progress, async () => {
-      const waitUntil = options.waitUntil === undefined ? 'load' : options.waitUntil;
-      progress.log(`setting frame content, waiting until "${waitUntil}"`);
-      const context = await progress.race(this._utilityContext());
-      const tagPromise = new ManualPromise<void>();
-      this._page.frameManager._consoleMessageTags.set(tag, () => {
-        // Clear lifecycle right after document.open() - see 'tag' below.
-        this._onClearLifecycle();
-        tagPromise.resolve();
-      });
-      const lifecyclePromise = progress.race(tagPromise).then(() => this.waitForLoadState(progress, waitUntil));
-      const contentPromise = progress.race(context.evaluate(({ html, tag }) => {
-        document.open();
-        console.debug(tag);  // eslint-disable-line no-console
-        document.write(html);
-        document.close();
-      }, { html, tag }));
-      await Promise.all([contentPromise, lifecyclePromise]);
-      return null;
-    }).finally(() => {
-      this._page.frameManager._consoleMessageTags.delete(tag);
-    });
+
+        await this.raceNavigationAction(progress, async () => {
+          const waitUntil = options.waitUntil === void 0 ? "load" : options.waitUntil;
+          progress.log(`setting frame content, waiting until "${waitUntil}"`);
+          const lifecyclePromise = new Promise((resolve, reject) => {
+            this._onClearLifecycle();
+            this.waitForLoadState(progress, waitUntil).then(resolve).catch(reject);
+          });
+          const setContentPromise = this._page.delegate._sessionForFrame(this)._client.send("Page.setDocumentContent", {
+            frameId: this._id,
+            html
+          });
+          await Promise.all([setContentPromise, lifecyclePromise]);
+
+          return null;
+        });
+    	
   }
 
   name(): string {
@@ -1101,60 +1240,14 @@
     progress: Progress,
     selector: string,
     options: { strict?: boolean, noAutoWaiting?: boolean, force?: boolean, performActionPreChecks?: boolean },
-    action: (handle: dom.ElementHandle<Element>) => Promise<R | 'error:notconnected'>): Promise<R> {
-    progress.log(`waiting for ${this._asLocator(selector)}`);
-    const noAutoWaiting = (options as any).__testHookNoAutoWaiting ?? options.noAutoWaiting;
-    const performActionPreChecks = (options.performActionPreChecks ?? !options.force) && !noAutoWaiting;
-    return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-      if (performActionPreChecks)
-        await this._page.performActionPreChecks(progress);
+    action: (handle: dom.ElementHandle<Element>) => Promise<R | 'error:notconnected'>, returnAction: 'returnOnNotResolved' | 'returnAll' | undefined): Promise<R> {
 
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, { strict: options.strict }));
-      if (!resolved) {
-        if (noAutoWaiting)
-          throw new dom.NonRecoverableDOMError('Element(s) not found');
-        return continuePolling;
-      }
-      const result = await progress.race(resolved.injected.evaluateHandle((injected, { info, callId }) => {
-        const elements = injected.querySelectorAll(info.parsed, document);
-        if (callId)
-          injected.markTargetElements(new Set(elements), callId);
-        const element = elements[0] as Element | undefined;
-        let log = '';
-        if (elements.length > 1) {
-          if (info.strict)
-            throw injected.strictModeViolationError(info.parsed, elements);
-          log = `  locator resolved to ${elements.length} elements. Proceeding with the first one: ${injected.previewNode(elements[0])}`;
-        } else if (element) {
-          log = `  locator resolved to ${injected.previewNode(element)}`;
-        }
-        injected.checkDeprecatedSelectorUsage(info.parsed, elements);
-        return { log, success: !!element, element };
-      }, { info: resolved.info, callId: progress.metadata.id }));
-      const { log, success } = await progress.race(result.evaluate(r => ({ log: r.log, success: r.success })));
-      if (log)
-        progress.log(log);
-      if (!success) {
-        if (noAutoWaiting)
-          throw new dom.NonRecoverableDOMError('Element(s) not found');
-        result.dispose();
-        return continuePolling;
-      }
-      const element = await progress.race(result.evaluateHandle(r => r.element)) as dom.ElementHandle<Element>;
-      result.dispose();
-      try {
-        const result = await action(element);
-        if (result === 'error:notconnected') {
-          if (noAutoWaiting)
-            throw new dom.NonRecoverableDOMError('Element is not attached to the DOM');
-          progress.log('element was detached from the DOM, retrying');
-          return continuePolling;
-        }
-        return result;
-      } finally {
-        element?.dispose();
-      }
-    });
+    			if (!(options as any)?.__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, options as any, action as any, returnAction, continuePolling);
+    			});
+    		
   }
 
   async rafrafTimeoutScreenshotElementWithProgress(progress: Progress, selector: string, timeout: number, options: ScreenshotOptions): Promise<Buffer> {
@@ -1307,20 +1400,61 @@
   }
 
   async isVisibleInternal(progress: Progress, selector: string, options: types.StrictOptions = {}, scope?: dom.ElementHandle): Promise<boolean> {
-    try {
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
-      if (!resolved)
-        return false;
-      return await progress.race(resolved.injected.evaluate((injected, { info, root }) => {
-        const element = injected.querySelector(info.parsed, root || document, info.strict);
-        const state = element ? injected.elementState(element, 'visible') : { matches: false, received: 'error:notconnected' };
-        return state.matches;
-      }, { info: resolved.info, root: resolved.frame === this ? scope : undefined }));
-    } catch (e) {
-      if (this.isNonRetriableError(e))
-        throw e;
-      return false;
-    }
+
+    		try {
+    			const metadata = { internal: false, log: [], method: "isVisible" };
+    			const progress = {
+    				log: message => metadata.log.push(message),
+    				metadata,
+    				race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
+    			}
+    			progress.log("waiting for " + this._asLocator(selector));
+    			if (selector === ":scope") {
+    				const scopeParentNode = scope.parentNode || scope;
+    				if (scopeParentNode instanceof dom.ElementHandle) {
+    					return await scopeParentNode.evaluateInUtility(([injected, node, { scope: handle2 }]) => {
+    						const state = handle2 ? injected.elementState(handle2, "visible") : {
+    							matches: false,
+    							received: "error:notconnected"
+    						};
+    						return state.matches;
+    					}, { scope });
+    				} else {
+    					return await scopeParentNode.evaluate((injected, node, { scope: handle2 }) => {
+    						const state = handle2 ? injected.elementState(handle2, "visible") : {
+    							matches: false,
+    							received: "error:notconnected"
+    						};
+    						return state.matches;
+    					}, { scope });
+    				}
+    			} else {
+    				return await this._retryWithoutProgress(progress, selector, { ...options, performActionPreChecks: false}, async (handle) => {
+    					if (!handle) return false;
+    					if (handle.parentNode instanceof dom.ElementHandle) {
+    						return await handle.parentNode.evaluateInUtility(([injected, node, { handle: handle2 }]) => {
+    							const state = handle2 ? injected.elementState(handle2, "visible") : {
+    								matches: false,
+    								received: "error:notconnected"
+    							};
+    							return state.matches;
+    						}, { handle });
+    					} else {
+    						return await handle.parentNode.evaluate((injected, { handle: handle2 }) => {
+    							const state = handle2 ? injected.elementState(handle2, "visible") : {
+    								matches: false,
+    								received: "error:notconnected"
+    							};
+    							return state.matches;
+    						}, { handle });
+    					}
+    				}, "returnOnNotResolved", null);
+    			}
+    		} catch (e) {
+    			if (this.isNonRetriableError(e)) throw e;
+    			return false;
+    		}
+    	
   }
 
   async isHidden(progress: Progress, selector: string, options: types.StrictOptions = {}, scope?: dom.ElementHandle): Promise<boolean> {
@@ -1439,47 +1573,96 @@
   }
 
   private async _expectInternal(progress: Progress, selector: string | undefined, options: FrameExpectParams, lastIntermediateResult: { received?: any, isSet: boolean, errorMessage?: string }, noAbort: boolean) {
-    // The first expect check, a.k.a. one-shot, always finishes - even when progress is aborted.
-    const race = <T>(p: Promise<T>) => noAbort ? p : progress.race(p);
-    const selectorInFrame = selector ? await race(this.selectors.resolveFrameForSelector(selector, { strict: true })) : undefined;
 
-    const { frame, info } = selectorInFrame || { frame: this, info: undefined };
-    const world = options.expression === 'to.have.property' ? 'main' : (info?.world ?? 'utility');
-    const context = await race(frame._context(world));
-    const injected = await race(context.injectedScript());
+    		// The first expect check, a.k.a. one-shot, always finishes - even when progress is aborted.
+    		const race = (p) => noAbort ? p : progress.race(p);
+    		const isArray = options.expression === 'to.have.count' || options.expression.endsWith('.array');
+    		var log, matches, received, missingReceived;
+    		if (selector) {
+    			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 };
+    					// expect(locator).toBeHidden() passes when there is no element.
+    					if (!options.isNot && options.expression === 'to.be.hidden')
+    						return { matches: true };
+    					// expect(locator).not.toBeVisible() passes when there is no element.
+    					if (options.isNot && options.expression === 'to.be.visible')
+    						return { matches: false };
+    					// expect(locator).toBeAttached({ attached: false }) passes when there is no element.
+    					if (!options.isNot && options.expression === 'to.be.detached')
+    						return { matches: true };
+    					// expect(locator).not.toBeAttached() passes when there is no element.
+    					if (options.isNot && options.expression === 'to.be.attached')
+    						return { matches: false };
+    					// expect(locator).not.toBeInViewport() passes when there is no element.
+    					if (options.isNot && options.expression === 'to.be.in.viewport')
+    						return { matches: false };
+    					// expect(locator).toHaveText([]) pass when there is no element.
+    					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: [] };
+    					}
+    					// When none of the above applies, expect does not match.
+    					return { matches: options.isNot, missingReceived: true };
+    				}
 
-    const { log, matches, received, missingReceived } = await race(injected.evaluate(async (injected, { info, options, callId }) => {
-      const elements = info ? injected.querySelectorAll(info.parsed, document) : [];
-      if (callId)
-        injected.markTargetElements(new Set(elements), callId);
-      const isArray = options.expression === 'to.have.count' || options.expression.endsWith('.array');
-      let log = '';
-      if (isArray)
-        log = `  locator resolved to ${elements.length} element${elements.length === 1 ? '' : 's'}`;
-      else if (elements.length > 1)
-        throw injected.strictModeViolationError(info!.parsed, elements);
-      else if (elements.length)
-        log = `  locator resolved to ${injected.previewNode(elements[0])}`;
-      if (info)
-        injected.checkDeprecatedSelectorUsage(info.parsed, elements);
-      return { log, ...await injected.expect(elements[0], options, elements) };
-    }, { info, options, callId: progress.metadata.id }));
+    				const handle = result[0];
+    				const handles = result[1];
 
-    if (log)
-      progress.log(log);
-    // Note: missingReceived avoids `unexpected value "undefined"` when element was not found.
-    if (matches === options.isNot) {
-      if (missingReceived) {
-        lastIntermediateResult.errorMessage = 'Error: element(s) not found';
-      } else {
-        lastIntermediateResult.errorMessage = undefined;
-        lastIntermediateResult.received = received;
-      }
-      lastIntermediateResult.isSet = true;
-      if (!missingReceived && !Array.isArray(received))
-        progress.log(`  unexpected value "${renderUnexpectedValue(options.expression, received)}"`);
-    }
-    return { matches, received };
+    				if (handle.parentNode instanceof dom.ElementHandle) {
+    					return await handle.parentNode.evaluateInUtility(async ([injected, node, { handle, options, handles }]) => {
+    						return await injected.expect(handle, options, handles);
+    					}, { handle, options, handles });
+    				} else {
+    					return await handle.parentNode.evaluate(async (injected, { handle, options, handles }) => {
+    						return await injected.expect(handle, options, handles);
+    					}, { handle, options, handles });
+    				}
+    			}
+
+    			if (noAbort) {
+    				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, { strict: !isArray, performActionPreChecks: false, __patchrightSkipRetryLogWaiting: true } as any, action, 'returnAll'));
+    			}
+    		} else {
+    			const world = options.expression === 'to.have.property' ? 'main' : 'utility';
+    			const context = await race(this._context(world));
+    			const injected = await race(context.injectedScript());
+    			var { matches, received, missingReceived } = await race(injected.evaluate(async (injected, { options, callId }) => {
+    				return { ...await injected.expect(undefined, options, []) };
+    			}, { options, callId: progress.metadata.id }));
+    		}
+
+
+    		if (log)
+    			progress.log(log);
+    		// Note: missingReceived avoids `unexpected value "undefined"` when element was not found.
+    		if (matches === options.isNot) {
+    			if (missingReceived) {
+    				lastIntermediateResult.errorMessage = 'Error: element(s) not found';
+    			} else {
+    				lastIntermediateResult.errorMessage = undefined;
+    				lastIntermediateResult.received = received;
+    			}
+    			lastIntermediateResult.isSet = true;
+    			if (!missingReceived) {
+    				const rendered = renderUnexpectedValue(options.expression, received);
+    				if (rendered !== undefined)
+    					progress.log('  unexpected value "' + rendered + '"');
+    			}
+    		}
+    		return { matches, received };
+    	
   }
 
   async waitForFunctionExpression<R>(progress: Progress, expression: string, isFunction: boolean | undefined, arg: any, options: { pollingInterval?: number }, world: types.World = 'main'): Promise<js.SmartHandle<R>> {
@@ -1538,7 +1721,7 @@
         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) {
         // Note: it is important to await "abort()" to prevent any side effects
         // after this method returns.
@@ -1591,42 +1774,129 @@
   }
 
   _onDetached() {
-    this._stopNetworkIdleTimer();
-    this._detachedScope.close(new Error('Frame was detached'));
-    for (const data of this._contextData.values()) {
-      if (data.context)
-        data.context.contextDestroyed('Frame was detached');
-      data.contextPromise.resolve({ destroyedReason: 'Frame was detached' });
-    }
-    if (this._parentFrame)
-      this._parentFrame._childFrames.delete(this);
-    this._parentFrame = null;
+
+    		this._stopNetworkIdleTimer();
+    		this._detachedScope.close(new Error('Frame was detached'));
+    		for (const data of this._contextData.values()) {
+    			if (data.context)
+    				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;
+    	
   }
 
   private async _callOnElementOnceMatches<T, R>(progress: Progress, selector: string, body: ElementCallback<T, R>, taskData: T, options: types.StrictOptions & { mainWorld?: boolean }, scope?: dom.ElementHandle): Promise<R> {
-    const callbackText = body.toString();
-    progress.log(`waiting for ${this._asLocator(selector)}`);
-    const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
-      if (!resolved)
-        return continuePolling;
-      const { log, success, value } = await progress.race(resolved.injected.evaluate((injected, { info, callbackText, taskData, callId, root }) => {
-        const callback = injected.eval(callbackText) as ElementCallback<T, R>;
-        const element = injected.querySelector(info.parsed, root || document, info.strict);
-        if (!element)
-          return { success: false };
-        const log = `  locator resolved to ${injected.previewNode(element)}`;
-        if (callId)
-          injected.markTargetElements(new Set([element]), callId);
-        return { log, success: true, value: callback(injected, element, taskData as T) };
-      }, { info: resolved.info, callbackText, taskData, callId: progress.metadata.id, root: resolved.frame === this ? scope : undefined }));
-      if (log)
-        progress.log(log);
-      if (!success)
-        return continuePolling;
-      return value!;
-    });
-    return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
+
+    		const callbackText = body.toString();
+    		progress.log("waiting for " + this._asLocator(selector));
+    		var promise;
+    		if (selector === ":scope") {
+    			const scopeParentNode = scope.parentNode || scope;
+    			if (scopeParentNode instanceof dom.ElementHandle) {
+    				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);
+    					return callback(injected, handle2, taskData2);
+    				}, {
+    					callbackText,
+    					scope,
+    					taskData
+    				});
+    			}
+    		} else {
+
+    			promise = this._retryWithProgressIfNotConnected(progress, selector, { ...options, performActionPreChecks: false }, async (handle) => {
+    				if (handle.parentNode instanceof dom.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();
+    						}
+    					}
+
+    					// Handling dispatch_event's in isolated and Main Contexts
+    					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);
+    						return callback(injected, handle2, taskData2);
+    					}, {
+    						callbackText,
+    						handle,
+    						taskData
+    					});
+    				} else {
+    					return await handle.parentNode.evaluate((injected, { callbackText: callbackText2, handle: handle2, taskData: taskData2 }) => {
+    						const callback = injected.eval(callbackText2);
+    						return callback(injected, handle2, taskData2);
+    					}, {
+    						callbackText,
+    						handle,
+    						taskData
+    					});
+    				}
+    			})
+    		}
+    		return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
+    	
   }
 
   private _setContext(world: types.World, context: dom.FrameExecutionContext | null) {
@@ -1722,6 +1992,325 @@
   private _asLocator(selector: string) {
     return asLocator(this._page.browserContext._browser.sdkLanguage(), selector);
   }
+
+  _isolatedWorld: dom.FrameExecutionContext;
+  _mainWorld: dom.FrameExecutionContext;
+  _iframeWorld: dom.FrameExecutionContext;
+
+  async _getFrameMainFrameContextId(client: CRSession): Promise<number> {
+
+    		try {
+    		  const frameOwner = await client._sendMayFail("DOM.getFrameOwner", { frameId: this._id });
+    		  if (!frameOwner?.nodeId)
+    		    return 0;
+
+    		  const describedNode = await client._sendMayFail("DOM.describeNode", { backendNodeId: frameOwner.backendNodeId });
+    		  if (!describedNode?.node.contentDocument)
+    		    return 0;
+
+    		  const resolvedNode = await client._sendMayFail("DOM.resolveNode", { backendNodeId: describedNode.node.contentDocument.backendNodeId });
+    		  if (!resolvedNode?.object?.objectId)
+    		    return 0;
+
+    		  return parseInt(resolvedNode.object.objectId.split(".")[1], 10);
+    		} catch (e) {}
+    		return 0;
+    	
+  }
+
+  async _retryWithoutProgress(progress: Progress, selector: string, options: { performActionPreChecks: boolean; strict?: boolean | null; state?: 'attached' | 'detached' | 'visible' | 'hidden'; noAutoWaiting?: boolean; __testHookNoAutoWaiting?: boolean; __patchrightWaitForSelector?: boolean; __patchrightInitialScope?: dom.ElementHandle; __patchrightSkipRetryLogWaiting?: boolean }, action: (result: dom.ElementHandle | [dom.ElementHandle, dom.ElementHandle[]] | null) => Promise<unknown>, returnAction: 'returnOnNotResolved' | 'returnAll' | undefined, continuePolling: symbol) {
+
+    		if (options.performActionPreChecks)
+    			await this._page.performActionPreChecks(progress);
+
+    		const resolved = await this.selectors.resolveInjectedForSelector(
+    			selector,
+    			{ strict: options.strict },
+    			 (options as any).__patchrightInitialScope
+    		);
+
+    		if (!resolved) {
+    			if (returnAction === 'returnOnNotResolved' || returnAction === 'returnAll') {
+    				const result = await action(null);
+    				return result === "internal:continuepolling" ? continuePolling : result;
+    			}
+    			return continuePolling;
+    		}
+
+    		const utilityContext = await resolved.frame._utilityContext();
+    		const mainContext = await resolved.frame._mainContext();
+    		let client;
+    		try {
+    			client = this._page.delegate._sessionForFrame(resolved.frame)._client;
+    		} catch (e) {
+    			client = this._page.delegate._mainFrameSession._client;
+    		}
+
+    		const documentNode = await client._sendMayFail('Runtime.evaluate', {
+    			expression: "document",
+    			serializationOptions: { serialization: "idOnly" },
+    			contextId: utilityContext.delegate._contextId,
+    		});
+    		if (!documentNode)
+    			return continuePolling;
+
+    		let initialScope = new dom.ElementHandle(utilityContext, documentNode.result.objectId);
+
+    		if ((resolved as any).scope) {
+    			const scopeObjectId = (resolved as any).scope._objectId;
+    			if (scopeObjectId) {
+    				const describeResult = await client._sendMayFail('DOM.describeNode', {
+    					objectId: scopeObjectId,
+    				});
+    				const backendNodeId = describeResult?.node?.backendNodeId;
+
+    				if (backendNodeId) {
+    					const scopeInUtility = await client._sendMayFail('DOM.resolveNode', {
+    						backendNodeId,
+    						executionContextId: utilityContext.delegate._contextId
+    					});
+
+    					if (scopeInUtility?.object?.objectId) {
+    						initialScope = new dom.ElementHandle(utilityContext, scopeInUtility.object.objectId);
+    					}
+    				}
+    			}
+    		}
+    		(progress as any).__patchrightInitialScope = (resolved as any).scope;
+
+    		// Save parsed selector before _customFindElementsByParsed mutates it via parts.shift()
+    		const parsedSnapshot = (options as any).__patchrightWaitForSelector ? JSON.parse(JSON.stringify(resolved.info.parsed)) : null;
+    		let currentScopingElements;
+    		try {
+    			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 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 as any).__testHookNoAutoWaiting || (options as any).noAutoWaiting)
+    				throw new dom.NonRecoverableDOMError('Element(s) not found');
+
+    			// CDP-based element search is non-atomic and can temporarily miss
+    			// elements during DOM mutations. Verify element absence in-page before reporting
+    			// "not found" to the waitForSelector callback.
+    			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 result = await action(null);
+    				return result === "internal:continuepolling" ? continuePolling : result;
+    			}
+    			return continuePolling;
+    		}
+
+    		const resultElement = currentScopingElements[0];
+    		await resultElement._initializePreview().catch(() => {});
+
+    		let visibilityQualifier = '';
+    		if (options && (options as any).__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, {
+    					info,
+    					elements
+    				}) => {
+    					throw injected.strictModeViolationError(info.parsed, elements);
+    				}, {
+    					info: resolved.info,
+    					elements: currentScopingElements
+    				}));
+    			}
+    			progress.log("  locator resolved to " + currentScopingElements.length + " elements. Proceeding with the first one: " + resultElement.preview());
+    		} else if (resultElement) {
+    			progress.log("  locator resolved to " + (visibilityQualifier ? visibilityQualifier + " " : "") + resultElement.preview().replace("JSHandle@", ""));
+    		}
+
+    		try {
+    			var result = null;
+    			if (returnAction === 'returnAll') {
+    				result = await action([resultElement, currentScopingElements]);
+    			} else {
+    				result = await action(resultElement);
+    			}
+    			if (result === 'error:notconnected') {
+    				progress.log('element was detached from the DOM, retrying');
+    				return continuePolling;
+    			} else if (result === 'internal:continuepolling') {
+    				return continuePolling;
+    			}
+    			// Verify no visible elements exist before accepting a null result to avoid stale CDP handles during mutations.
+    			if (parsedSnapshot && result === null && ((options as any).state === 'hidden' || (options as any).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 {}
+    	
+  }
+
+  async _customFindElementsByParsed(resolved: { injected: js.JSHandle<InjectedScript>, info: { parsed: ParsedSelector, strict: boolean }, frame: Frame, scope?: dom.ElementHandle }, client: CRSession, context: dom.FrameExecutionContext, documentScope: dom.ElementHandle, progress: Progress, parsed: ParsedSelector) {
+
+    		var parsedEdits = { ...parsed };
+    		// Note: We start scoping at document level
+    		var currentScopingElements = [documentScope];
+
+    		for (const part of [...parsed.parts]) {
+    			parsedEdits.parts = [part];
+    			var elements = [];
+
+    			if (part.name === "nth") {
+    				const partNth = Number(part.body);
+    				// Check if any Elements are currently scoped, else return empty array to continue polling
+    				if (currentScopingElements.length == 0)
+    					return [];
+
+    				if (partNth > currentScopingElements.length-1 || partNth < -(currentScopingElements.length-1)) {
+    					if (parsed.capture !== undefined)
+    						throw new Error("Can't query n-th element in a request with the capture.");
+    					return [];
+    				}
+    				currentScopingElements = [currentScopingElements.at(partNth)];
+    				continue;
+    			} else if (part.name === "internal:or") {
+    				var orredElements = await this._customFindElementsByParsed(resolved, client, context, documentScope, progress, part.body.parsed);
+    				elements = [...currentScopingElements, ...orredElements];
+    			} else if (part.name == "internal:and") {
+    				var andedElements = await this._customFindElementsByParsed(resolved, client, context, documentScope, progress, part.body.parsed);
+    				const backendNodeIds = new Set(andedElements.map(elem => elem.backendNodeId));
+    				elements = currentScopingElements.filter(elem => backendNodeIds.has(elem.backendNodeId));
+    			} else {
+    				for (const scope of currentScopingElements) {
+    					const describedScope = await client.send("DOM.describeNode", {
+    						objectId: scope._objectId,
+    						depth: -1,
+    						pierce: true
+    					});
+
+    					let findClosedShadowRoots = function(node, results = []) {
+    						if (!node || typeof node !== "object") return results;
+    						if (node.shadowRoots && Array.isArray(node.shadowRoots)) {
+    							for (const shadowRoot of node.shadowRoots) {
+    								if (shadowRoot.shadowRootType === "closed" && shadowRoot.backendNodeId) {
+    									results.push(shadowRoot.backendNodeId);
+    								}
+    								findClosedShadowRoots(shadowRoot, results);
+    							}
+    						}
+    						if (node.nodeName !== "IFRAME" && node.children && Array.isArray(node.children)) {
+    							for (const child of node.children) {
+    								findClosedShadowRoots(child, results);
+    							}
+    						}
+    						return results;
+    					};
+    					var shadowRootBackendIds = findClosedShadowRoots(describedScope.node);
+
+    					const shadowRoots = await Promise.all(
+    						shadowRootBackendIds.map(async backendNodeId => {
+    							const resolved = await client.send("DOM.resolveNode", {
+    								backendNodeId,
+    								contextId: context.delegate._contextId,
+    							});
+    							return new dom.ElementHandle(context, resolved.object.objectId);
+    						})
+    					);
+
+    					// Elements Queryed in the "current round"
+    					const queryGroups: { handles: any; parentNode: any }[] = [];
+    					for (var shadowRoot of shadowRoots) {
+    						const shadowHandles = await shadowRoot.evaluateHandleInUtility(
+    							([injected, node, { parsed, callId }]) => {
+    							 	const elements = injected.querySelectorAll(parsed, node);
+    								if (callId)
+    									injected.markTargetElements(new Set(elements), callId);
+    								return elements;
+    							}, {
+    								parsed: parsedEdits,
+    								callId: progress.metadata.id
+    							}
+    						);
+    						queryGroups.push({ handles: shadowHandles, parentNode: shadowRoot });
+    					}
+
+    					// Document Root Elements (not in CSR)
+    					const rootHandles = await scope.evaluateHandleInUtility(
+    						([injected, node, { parsed, callId }]) => {
+    						 	const elements = injected.querySelectorAll(parsed, node);
+    							if (callId)
+    								injected.markTargetElements(new Set(elements), callId);
+    							return elements;
+    						}, {
+    							parsed: parsedEdits,
+    							callId: progress.metadata.id
+    						}
+    					);
+    					queryGroups.push({ handles: rootHandles, parentNode: scope });
+
+    					// Querying and Sorting the elements by their backendNodeId
+    					for (const { handles, parentNode } of queryGroups) {
+    						const handlesAmount = await (await handles.getProperty("length")).jsonValue();
+    						for (var i = 0; i < handlesAmount; i++) {
+    						  if (parentNode instanceof dom.ElementHandle) {
+    								var element = await parentNode.evaluateHandleInUtility(
+    									([injected, node, { i, handles: elems }]) => elems[i],
+    									{ i, handles }
+    								);
+    							} else {
+    								var element = await parentNode.evaluateHandle(
+    									(injected, { i, handles: elems }) => elems[i],
+    									{ i, handles }
+    								);
+    							}
+
+    							// For other Functions/Utilities
+    							element.parentNode = parentNode;
+    							const resolvedElement = await client.send("DOM.describeNode", { objectId: element._objectId, depth: -1 });
+    							element.backendNodeId = resolvedElement.node.backendNodeId;
+    							element.nodePosition = await this.selectors._findElementPositionInDomTree(element, describedScope.node, context, "");
+    							elements.push(element);
+    						}
+    					}
+    				}
+    			}
+
+    			// Sorting elements by their nodePosition, which is a index to the Element in the DOM tree
+    			const getParts = (pos) => (pos || '').split('.').filter(Boolean).map(Number);
+    			elements.sort((a, b) => {
+    				const partsA = getParts(a.nodePosition);
+    				const partsB = getParts(b.nodePosition);
+
+    				for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    					const diff = (partsA[i] ?? -1) - (partsB[i] ?? -1);
+    					if (diff !== 0) return diff;
+    				}
+    				return 0;
+    			});
+
+    			// Remove duplicates by backendNodeId, keeping the first occurrence
+    			currentScopingElements = Array.from(
+    				new Map(elements.map(e => [e.backendNodeId, e])).values()
+    			);
+    		}
+
+    		return currentScopingElements;
+    	
+  }
 }
 
 class SignalBarrier {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/javascript.ts patchright/node_modules/playwright-core/src/server/javascript.ts
---
+++
@@ -22,6 +22,7 @@
 
 import type * as dom from './dom';
 import type { UtilityScript } from '@injected/utilityScript';
+import * as domValue from "./dom";
 
 interface TaggedAsJSHandle<T> {
   __jshandle: T;
@@ -149,17 +150,45 @@
     return evaluate(this._context, false /* returnByValue */, pageFunction, this, arg);
   }
 
-  async evaluateExpression(expression: string, options: { isFunction?: boolean }, arg: any) {
-    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: true }, this, arg);
-    await this._context.doSlowMo();
-    return value;
-  }
+  async evaluateExpression(expression: string, options: { isFunction?: boolean }, arg: any, isolatedContext?: boolean) {
 
-  async evaluateExpressionHandle(expression: string, options: { isFunction?: boolean }, arg: any): Promise<JSHandle<any>> {
-    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: false }, this, arg);
-    await this._context.doSlowMo();
-    return value;
-  }
+    		let context = this._context;
+    		if (context instanceof domValue.FrameExecutionContext) {
+    			const frame = context.frame;
+    			if (frame) {
+    				if (isolatedContext === true)
+    					context = await frame._utilityContext();
+    				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;
+    }
+
+  async evaluateExpressionHandle(expression: string, options: { isFunction?: boolean }, arg: any, isolatedContext?: boolean): Promise<JSHandle<any>> {
+
+    		let context = this._context;
+    		if (context instanceof domValue.FrameExecutionContext) {
+    			const frame = context.frame;
+    			if (frame) {
+    				if (isolatedContext === true)
+    					context = await frame._utilityContext();
+    				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;
+    }
 
   async getProperty(propertyName: string): Promise<JSHandle> {
     const objectHandle = await this.evaluateHandle((object: any, propertyName) => {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/launchApp.ts patchright/node_modules/playwright-core/src/server/launchApp.ts
---
+++
@@ -117,7 +117,8 @@
             return;
           Object.entries(settings).map(([k, v]) => localStorage[k] = v);
           (window as any).saveSettings = () => {
-            (window as any)._saveSerializedSettings(JSON.stringify({ ...localStorage }));
+            if (typeof (window as any)._saveSerializedSettings === 'function')
+				(window as any)._saveSerializedSettings(JSON.stringify({ ...localStorage }));
           };
         })})(${settings});
     `);
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/page.ts patchright/node_modules/playwright-core/src/server/page.ts
---
+++
@@ -51,6 +51,8 @@
 import type * as channels from '@protocol/channels';
 import type { BindingPayload } from '@injected/bindingsController';
 import type { SelectorInfo } from './frameSelectors';
+import * as domValue from "./dom";
+import { createPageBindingScript, deliverBindingResult, takeBindingHandle } from "./pageBinding";
 
 export interface PageDelegate {
   readonly rawMouse: input.RawMouse;
@@ -332,21 +334,16 @@
   }
 
   async exposeBinding(progress: Progress, name: string, needsHandle: boolean, playwrightBinding: frames.FunctionWithSource): Promise<PageBinding> {
-    if (this._pageBindings.has(name))
-      throw new Error(`Function "${name}" has been already registered`);
-    if (this.browserContext._pageBindings.has(name))
-      throw new Error(`Function "${name}" has been already registered in the browser context`);
-    await progress.race(this.browserContext.exposePlaywrightBindingIfNeeded());
-    const binding = new PageBinding(this, name, playwrightBinding, needsHandle);
-    this._pageBindings.set(name, binding);
-    try {
-      await progress.race(this.delegate.addInitScript(binding.initScript));
-      await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, 'main'));
-      return binding;
-    } catch (error) {
-      this._pageBindings.delete(name);
-      throw error;
-    }
+
+    		if (this._pageBindings.has(name))
+    			throw new Error(`Function "${name}" has been already registered`);
+    		if (this.browserContext._pageBindings.has(name))
+    			throw new Error(`Function "${name}" has been already registered in the browser context`);
+    		const binding = new PageBinding(this, name, playwrightBinding, needsHandle);
+    		this._pageBindings.set(name, binding);
+    		await this.delegate.exposeBinding(binding);
+    		return binding;
+    	
   }
 
   async removeExposedBinding(binding: PageBinding) {
@@ -870,13 +867,6 @@
     }
   }
 
-  allInitScripts() {
-    const bindings = [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()].map(binding => binding.initScript);
-    if (this.browserContext.bindingsInitScript)
-      bindings.unshift(this.browserContext.bindingsInitScript);
-    return [...bindings, ...this.browserContext.initScripts, ...this.initScripts];
-  }
-
   getBinding(name: string) {
     return this._pageBindings.get(name) || this.browserContext._pageBindings.get(name);
   }
@@ -899,6 +889,12 @@
   async setDockTile(image: Buffer) {
     await this.delegate.setDockTile(image);
   }
+
+  allBindings() {
+
+    		return [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()];
+    	
+  }
 }
 
 export const WorkerEvent = {
@@ -953,83 +949,119 @@
     this.openScope.close(new Error('Worker closed'));
   }
 
-  async evaluateExpression(expression: string, isFunction: boolean | undefined, arg: any): Promise<any> {
-    return js.evaluateExpression(await this._executionContextPromise, expression, { returnByValue: true, isFunction }, arg);
-  }
+  async evaluateExpression(expression: string, isFunction: boolean | undefined, arg: any, isolatedContext?: boolean): Promise<any> {
 
-  async evaluateExpressionHandle(expression: string, isFunction: boolean | undefined, arg: any): Promise<any> {
-    return js.evaluateExpression(await this._executionContextPromise, expression, { returnByValue: false, isFunction }, arg);
-  }
+    			let context = await this._executionContextPromise;
+    			if (context instanceof domValue.FrameExecutionContext) {
+    				const frame = context.frame;
+    				if (frame) {
+    					if (isolatedContext) context = await frame._utilityContext();
+    					else if (!isolatedContext) context = await frame._mainContext();
+    				}
+    			}
+    		
+      return js.evaluateExpression(context, expression, { returnByValue: true, isFunction }, arg);
+    }
+
+  async evaluateExpressionHandle(expression: string, isFunction: boolean | undefined, arg: any, isolatedContext?: boolean): Promise<any> {
+
+    			let context = await this._executionContextPromise;
+    			if (context instanceof domValue.FrameExecutionContext) {
+    				const frame = context.frame;
+    				if (frame) {
+    					if (isolatedContext) context = await frame._utilityContext();
+    					else if (!isolatedContext) context = await frame._mainContext();
+    				}
+    			}
+    		
+      return js.evaluateExpression(context, expression, { returnByValue: false, isFunction }, arg);
+    }
 }
 
-export class PageBinding extends DisposableObject {
-  private static kController = '__playwright__binding__controller__';
-  static kBindingName = '__playwright__binding__';
 
-  static createInitScript(browserContext: BrowserContext): InitScript {
-    return new InitScript(browserContext, `
-      (() => {
-        const module = {};
-        ${rawBindingsControllerSource.source}
-        const property = '${PageBinding.kController}';
-        if (!globalThis[property])
-          globalThis[property] = new (module.exports.BindingsController())(globalThis, '${PageBinding.kBindingName}');
-      })();
-    `);
-  }
+		export class PageBinding extends DisposableObject {
+			readonly source: string;
+			readonly name: string;
+			readonly playwrightFunction: frames.FunctionWithSource;
+			readonly initScript: InitScript;
+			readonly needsHandle: boolean;
+			readonly cleanupScript: string;
+			forClient?: unknown;
 
-  readonly name: string;
-  readonly playwrightFunction: frames.FunctionWithSource;
-  readonly initScript: InitScript;
-  readonly needsHandle: boolean;
-  readonly cleanupScript: string;
-  forClient?: unknown;
+			constructor(parent: BrowserContext | Page, name: string, playwrightFunction: frames.FunctionWithSource, needsHandle: boolean) {
+				super(parent);
+				this.name = name;
+				this.playwrightFunction = playwrightFunction;
+				this.initScript = new InitScript(parent, createPageBindingScript(name, needsHandle));
+				this.source = this.initScript.source;
+				this.cleanupScript = `delete globalThis[${JSON.stringify(name)}];`;
+				this.needsHandle = needsHandle;
+			}
 
-  constructor(parent: BrowserContext | Page, name: string, playwrightFunction: frames.FunctionWithSource, needsHandle: boolean) {
-    super(parent);
-    this.name = name;
-    this.playwrightFunction = playwrightFunction;
-    this.initScript = new InitScript(parent, `globalThis['${PageBinding.kController}'].addBinding(${JSON.stringify(name)}, ${needsHandle})`);
-    this.needsHandle = needsHandle;
-    this.cleanupScript = `globalThis['${PageBinding.kController}'].removeBinding(${JSON.stringify(name)})`;
-  }
+			static async dispatch(page: Page, payload: string, context: dom.FrameExecutionContext) {
+				const { name, seq, serializedArgs } = JSON.parse(payload) as BindingPayload;
 
-  static async dispatch(page: Page, payload: string, context: dom.FrameExecutionContext) {
-    const { name, seq, serializedArgs } = JSON.parse(payload) as BindingPayload;
-    try {
-      assert(context.world);
-      const binding = page.getBinding(name);
-      if (!binding)
-        throw new Error(`Function "${name}" is not exposed`);
-      let result: any;
-      if (binding.needsHandle) {
-        const handle = await context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].takeBindingHandle(arg)`, { isFunction: true }, { name, seq }).catch(e => null);
-        result = await binding.playwrightFunction({ frame: context.frame, page, context: page.browserContext }, handle);
-      } else {
-        if (!Array.isArray(serializedArgs))
-          throw new Error(`serializedArgs is not an array. This can happen when Array.prototype.toJSON is defined incorrectly`);
-        const args = serializedArgs!.map(a => parseEvaluationResultValue(a));
-        result = await binding.playwrightFunction({ frame: context.frame, page, context: page.browserContext }, ...args);
-      }
-      context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].deliverBindingResult(arg)`, { isFunction: true }, { name, seq, result }).catch(e => debugLogger.log('error', e));
-    } catch (error) {
-      context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].deliverBindingResult(arg)`, { isFunction: true }, { name, seq, error }).catch(e => debugLogger.log('error', e));
-    }
-  }
+				const deliver = async (deliverPayload: any) => {
+					let deliveryError: any;
+					try {
+						await context.evaluate(deliverBindingResult, deliverPayload);
+						return;
+					} catch (e) {
+						deliveryError = e;
+					}
+					const frame = context.frame;
+					if (!frame) {
+						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(deliverBindingResult, deliverPayload);
+							return;
+						} catch {
+						}
+					}
+					debugLogger.log('error', deliveryError);
+				};
 
-  override async dispose(): Promise<void> {
-    await this.parent.removeExposedBinding(this);
-  }
-}
+				try {
+					assert(context.world);
+					const binding = page.getBinding(name);
+					if (!binding)
+						throw new Error(`Function "${name}" is not exposed`);
+
+					let result: any;
+					if (binding.needsHandle) {
+						const handle = await context.evaluateHandle(takeBindingHandle, { name, seq }).catch(e => null);
+						result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, handle);
+					} else {
+						if (!Array.isArray(serializedArgs))
+							throw new Error(`serializedArgs is not an array. This can happen when Array.prototype.toJSON is defined incorrectly`);
+						const args = serializedArgs!.map(a => parseEvaluationResultValue(a));
+						result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, ...args);
+					}
+					await deliver({ name, seq, result });
+				} catch (error) {
+					await deliver({ name, seq, error });
+				}
+			}
+
+			override async dispose(): Promise<void> {
+				await this.parent.removeExposedBinding(this);
+			}
+		}
+	
 
 export class InitScript extends DisposableObject {
   readonly source: string;
 
   constructor(owner: BrowserContext | Page, source: string) {
     super(owner);
-    this.source = `(() => {
-      ${source}
-    })();`;
+    this.source = `(() => { ${source} })();`;
   }
 
   async dispose() {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/pageBinding.ts patchright/node_modules/playwright-core/src/server/pageBinding.ts
---
+++
@@ -0,0 +1,91 @@
+;
+		/**
+		 * Copyright (c) Microsoft Corporation.
+		 *
+		 * Licensed under the Apache License, Version 2.0 (the "License");
+		 * you may not use this file except in compliance with the License.
+		 * You may obtain a copy of the License at
+		 *
+		 * http://www.apache.org/licenses/LICENSE-2.0
+		 *
+		 * Unless required by applicable law or agreed to in writing, software
+		 * distributed under the License is distributed on an "AS IS" BASIS,
+		 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+		 * See the License for the specific language governing permissions and
+		 * limitations under the License.
+		 */
+		import { source } from '../utils/isomorphic/oldUtilityScriptSerializers';
+
+		import type { SerializedValue } from '../utils/isomorphic/oldUtilityScriptSerializers';
+
+		export type BindingPayload = {
+			name: string;
+			seq: number;
+			serializedArgs?: SerializedValue[],
+		};
+
+		function addPageBinding(bindingName: string, needsHandle: boolean, utilityScriptSerializersFactory: typeof source) {
+			const { serializeAsCallArgument } = utilityScriptSerializersFactory;
+			// eslint-disable-next-line no-restricted-globals
+			const binding = (globalThis as any)[bindingName];
+			if (!binding || binding.toString().startsWith("(...args) => {")) return
+			// eslint-disable-next-line no-restricted-globals
+			(globalThis as any)[bindingName] = (...args: any[]) => {
+			// eslint-disable-next-line no-restricted-globals
+				const me = (globalThis as any)[bindingName];
+				if (needsHandle && args.slice(1).some(arg => arg !== undefined))
+					throw new Error(`exposeBindingHandle supports a single argument, ${args.length} received`);
+				let callbacks = me['callbacks'];
+				if (!callbacks) {
+					callbacks = new Map();
+					me['callbacks'] = callbacks;
+				}
+				const seq: number = (me['lastSeq'] || 0) + 1;
+				me['lastSeq'] = seq;
+				let handles = me['handles'];
+				if (!handles) {
+					handles = new Map();
+					me['handles'] = handles;
+				}
+				const promise = new Promise((resolve, reject) => callbacks.set(seq, { resolve, reject }));
+				let payload: BindingPayload;
+				if (needsHandle) {
+					handles.set(seq, args[0]);
+					payload = { name: bindingName, seq };
+				} else {
+					const serializedArgs = [];
+					for (let i = 0; i < args.length; i++) {
+						serializedArgs[i] = serializeAsCallArgument(args[i], v => {
+							return { fallThrough: v };
+						});
+					}
+					payload = { name: bindingName, seq, serializedArgs };
+				}
+				binding(JSON.stringify(payload));
+				return promise;
+			};
+			// eslint-disable-next-line no-restricted-globals
+		}
+
+		export function takeBindingHandle(arg: { name: string, seq: number }) {
+			// eslint-disable-next-line no-restricted-globals
+			const handles = (globalThis as any)[arg.name]['handles'];
+			const handle = handles.get(arg.seq);
+			handles.delete(arg.seq);
+			return handle;
+		}
+
+		export function deliverBindingResult(arg: { name: string, seq: number, result?: any, error?: any }) {
+			// eslint-disable-next-line no-restricted-globals
+			const callbacks = (globalThis as any)[arg.name]['callbacks'];
+			if ('error' in arg)
+				callbacks.get(arg.seq).reject(arg.error);
+			else
+				callbacks.get(arg.seq).resolve(arg.result);
+			callbacks.delete(arg.seq);
+		}
+
+		export function createPageBindingScript(name: string, needsHandle: boolean) {
+			return `(${addPageBinding.toString()})(${JSON.stringify(name)}, ${needsHandle}, (${source})())`;
+		}
+	
\ No newline at end of file
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/registry/index.ts patchright/node_modules/playwright-core/src/server/registry/index.ts
---
+++
@@ -1,20 +1,3 @@
-/**
- * Copyright 2017 Google Inc. All rights reserved.
- * Modifications copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
@@ -600,7 +583,7 @@
             `-  current: ${currentDockerVersion.dockerImageName}`,
             `- required: ${preferredDockerVersion.dockerImageName}`,
             ``,
-            `<3 Playwright Team`,
+            `<3 Patchright Team`,
           ].join('\n');
         } else if (isFfmpeg) {
           prettyMessage = [
@@ -610,7 +593,7 @@
             ``,
             `    ${buildPlaywrightCLICommand(sdkLanguage, 'install ffmpeg')}`,
             ``,
-            `<3 Playwright Team`,
+            `<3 Patchright Team`,
           ].join('\n');
         } else {
           prettyMessage = [
@@ -619,7 +602,7 @@
             ``,
             `    ${installCommand}`,
             ``,
-            `<3 Playwright Team`,
+            `<3 Patchright Team`,
           ].join('\n');
         }
         throw new Error(`Executable doesn't exist at ${e}\n${wrapInASCIIBox(prettyMessage, 1)}`);
@@ -1083,7 +1066,7 @@
       // Install browsers for this package.
       for (const executable of executables) {
         if (!executable._install)
-          throw new Error(`ERROR: Playwright does not support installing ${executable.name}`);
+          throw new Error(`ERROR: Patchright does not support installing ${executable.name}`);
 
         if (!getAsBooleanFromENV('CI') && !executable._isHermeticInstallation && !options?.force && executable.executablePath()) {
           const { embedderName } = getEmbedderName();
@@ -1102,7 +1085,7 @@
             ``,
             `    ${command}`,
             ``,
-            `<3 Playwright Team`,
+            `<3 Patchright Team`,
           ].join('\n'), 1) + '\n\n');
           return;
         }
@@ -1117,12 +1100,12 @@
           `  ${lockfilePath}`,
           ``,
           `Either:`,
-          `- wait a few minutes if other Playwright is installing browsers in parallel`,
+          `- wait a few minutes if other Patchright is installing browsers in parallel`,
           `- remove lock manually with:`,
           ``,
           `    ${rmCommand} ${lockfilePath}`,
           ``,
-          `<3 Playwright Team`,
+          `<3 Patchright Team`,
         ].join('\n'), 1));
       } else {
         throw e;
@@ -1217,13 +1200,13 @@
   private async _downloadExecutable(descriptor: BrowsersJSONDescriptor, force: boolean, executablePath?: string) {
     const downloadURLs = this._downloadURLs(descriptor);
     if (!downloadURLs.length)
-      throw new Error(`ERROR: Playwright does not support ${descriptor.name} on ${hostPlatform}`);
+      throw new Error(`ERROR: Patchright does not support ${descriptor.name} on ${hostPlatform}`);
     if (!isOfficiallySupportedPlatform)
-      logPolitely(`BEWARE: your OS is not officially supported by Playwright; downloading fallback build for ${hostPlatform}.`);
+      logPolitely(`BEWARE: your OS is not officially supported by Patchright; downloading fallback build for ${hostPlatform}.`);
     if (descriptor.hasRevisionOverride) {
       const message = `You are using a frozen ${descriptor.name} browser which does not receive updates anymore on ${hostPlatform}. Please update to the latest version of your operating system to test up-to-date browsers.`;
       if (process.env.GITHUB_ACTIONS)
-        console.log(`::warning title=Playwright::${message}`);  // eslint-disable-line no-console
+        console.log(`::warning title=Patchright::${message}`);  // eslint-disable-line no-console
       else
         logPolitely(message);
     }
@@ -1444,7 +1427,7 @@
 export function buildPlaywrightCLICommand(sdkLanguage: string, parameters: string): string {
   switch (sdkLanguage) {
     case 'python':
-      return `playwright ${parameters}`;
+      return `patchright ${parameters}`;
     case 'java':
       return `mvn exec:java -e -D exec.mainClass=com.microsoft.playwright.CLI -D exec.args="${parameters}"`;
     case 'csharp':
@@ -1497,7 +1480,7 @@
       ``,
       `    ${installCommand}`,
       ``,
-      `<3 Playwright Team`,
+      `<3 Patchright Team`,
     ].join('\n');
     throw new Error('\n' + wrapInASCIIBox(prettyMessage, 1));
   }
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/screenshotter.ts patchright/node_modules/playwright-core/src/server/screenshotter.ts
---
+++
@@ -254,6 +254,11 @@
     if (disableAnimations)
       progress.log('  disabled all CSS animations');
     const syncAnimations = this._page.delegate.shouldToggleStyleSheetToSyncAnimations();
+
+    			await Promise.all(this._page.frames().map(async (f: any) => {
+    				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) {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/trace/recorder/snapshotter.ts patchright/node_modules/playwright-core/src/server/trace/recorder/snapshotter.ts
---
+++
@@ -26,7 +26,6 @@
 import type { SnapshotData } from './snapshotterInjected';
 import type { RegisteredListener } from '../../utils/eventsHelper';
 import type { Frame } from '../../frames';
-import type { InitScript } from '../../page';
 import type { FrameSnapshot } from '@trace/snapshot';
 
 export type SnapshotterBlob = {
@@ -44,7 +43,7 @@
   private _delegate: SnapshotterDelegate;
   private _eventListeners: RegisteredListener[] = [];
   private _snapshotStreamer: string;
-  private _initScript: InitScript | undefined;
+  private _initScript: boolean | undefined;
   private _started = false;
 
   constructor(context: BrowserContext, delegate: SnapshotterDelegate) {
@@ -67,7 +66,7 @@
 
   async reset() {
     if (this._started)
-      await this._context.safeNonStallingEvaluateInAllFrames(`window["${this._snapshotStreamer}"].reset()`, 'main');
+      await this._context.safeNonStallingEvaluateInAllFrames(`window["${this._snapshotStreamer}"].reset()`, 'utility');
   }
 
   stop() {
@@ -75,25 +74,27 @@
   }
 
   async resetForReuse() {
-    // Next time we start recording, we will call addInitScript again.
-    if (this._initScript) {
-      eventsHelper.removeEventListeners(this._eventListeners);
-      await this._initScript.dispose();
-      this._initScript = undefined;
-    }
+
+    		if (this._initScript) {
+    			eventsHelper.removeEventListeners(this._eventListeners);
+    			this._initScript = undefined;
+    			this._initScriptSource = undefined;
+    		}
+    	
   }
 
   async _initialize() {
-    for (const page of this._context.pages())
-      this._onPage(page);
-    this._eventListeners = [
-      eventsHelper.addEventListener(this._context, BrowserContext.Events.Page, this._onPage.bind(this)),
-    ];
 
-    const { javaScriptEnabled } = this._context._options;
-    const initScriptSource = `(${frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === undefined})`;
-    this._initScript = await this._context.addInitScript(initScriptSource);
-    await this._context.safeNonStallingEvaluateInAllFrames(initScriptSource, 'main');
+    		const { javaScriptEnabled } = this._context._options;
+    		this._initScriptSource = `(${frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === undefined})`;
+    		this._initScript = true;
+    		for (const page of this._context.pages())
+    			this._onPage(page);
+    		this._eventListeners = [
+    			eventsHelper.addEventListener(this._context, BrowserContext.Events.Page, this._onPage.bind(this)),
+    		];
+    		await this._context.safeNonStallingEvaluateInAllFrames(this._initScriptSource, 'utility');
+    	
   }
 
   dispose() {
@@ -106,7 +107,7 @@
     (frame as any)[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) {
       // If we fail to capture snapshot in this frame, we cannot rely on the snapshot index
       // being the same here and in snapshotter injected script.
@@ -159,6 +160,7 @@
     for (const frame of page.frames())
       this._annotateFrameHierarchy(frame);
     this._eventListeners.push(eventsHelper.addEventListener(page, Page.Events.FrameAttached, frame => this._annotateFrameHierarchy(frame)));
+    this._eventListeners.push(eventsHelper.addEventListener(page, Page.Events.InternalFrameNavigatedToNewDocument, (frame: Frame) => this._onFrameNavigated(frame)));
   }
 
   private async _annotateFrameHierarchy(frame: Frame) {
@@ -167,7 +169,7 @@
       const parent = frame.parentFrame();
       if (!parent)
         return;
-      const context = await parent._mainContext();
+      const context = await parent._utilityContext();
       await context?.evaluate(({ snapshotStreamer, frameElement, frameId }) => {
         (window as any)[snapshotStreamer].markIframe(frameElement, frameId);
       }, { snapshotStreamer: this._snapshotStreamer, frameElement, frameId: frame.guid });
@@ -175,6 +177,18 @@
     } catch (e) {
     }
   }
+
+  _initScriptSource: string | undefined;
+
+  async _onFrameNavigated(frame: Frame) {
+
+    		if (!this._initScriptSource)
+    			return;
+    		try {
+    			await frame.nonStallingEvaluateInExistingContext(this._initScriptSource, 'utility');
+    		} catch (e) {}
+    	
+  }
 }
 
 const kNeedsResetSymbol = Symbol('kNeedsReset');
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/trace/recorder/snapshotterInjected.ts patchright/node_modules/playwright-core/src/server/trace/recorder/snapshotterInjected.ts
---
+++
@@ -85,33 +85,15 @@
 
   class Streamer {
     private _lastSnapshotNumber = 0;
-    private _staleStyleSheets = new Set<CSSStyleSheet>();
     private _modifiedStyleSheets = new Set<CSSStyleSheet>();
-    private _readingStyleSheet = false;  // To avoid invalidating due to our own reads.
     private _fakeBase: HTMLBaseElement;
     private _observer: MutationObserver;
 
     constructor() {
-      const invalidateCSSGroupingRule = (rule: CSSGroupingRule) => {
-        if (rule.parentStyleSheet)
-          this._invalidateStyleSheet(rule.parentStyleSheet);
-      };
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, 'insertRule', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, 'deleteRule', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, 'addRule', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, 'removeRule', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeGetter(window.CSSStyleSheet.prototype, 'rules', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeGetter(window.CSSStyleSheet.prototype, 'cssRules', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, 'replaceSync', (sheet: CSSStyleSheet) => 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: StyleSheet) => {
         if (sheet instanceof CSSStyleSheet)
           this._invalidateStyleSheet(sheet as CSSStyleSheet);
       });
-      this._interceptNativeAsyncMethod(window.CSSStyleSheet.prototype, 'replace', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-
       this._fakeBase = document.createElement('base');
 
       this._observer = new MutationObserver(list => this._handleMutations(list));
@@ -162,40 +144,6 @@
       });
     }
 
-    private _interceptNativeMethod(obj: any, method: string, cb: (thisObj: any, result: any) => void) {
-      const native = obj[method] as Function;
-      if (!native)
-        return;
-      obj[method] = function(...args: any[]) {
-        const result = native.call(this, ...args);
-        cb(this, result);
-        return result;
-      };
-    }
-
-    private _interceptNativeAsyncMethod(obj: any, method: string, cb: (thisObj: any, result: any) => void) {
-      const native = obj[method] as Function;
-      if (!native)
-        return;
-      obj[method] = async function(...args: any[]) {
-        const result = await native.call(this, ...args);
-        cb(this, result);
-        return result;
-      };
-    }
-
-    private _interceptNativeGetter(obj: any, prop: string, cb: (thisObj: any, result: any) => void) {
-      const descriptor = Object.getOwnPropertyDescriptor(obj, prop)!;
-      Object.defineProperty(obj, prop, {
-        ...descriptor,
-        get: function() {
-          const result = descriptor.get!.call(this);
-          cb(this, result);
-          return result;
-        },
-      });
-    }
-
     private _interceptNativeSetter(obj: any, prop: string, cb: (thisObj: any, result: any) => void) {
       const descriptor = Object.getOwnPropertyDescriptor(obj, prop)!;
       Object.defineProperty(obj, prop, {
@@ -213,42 +161,37 @@
         ensureCachedData(mutation.target).attributesCached = undefined;
     }
 
-    private _invalidateStyleSheet(sheet: CSSStyleSheet) {
-      if (this._readingStyleSheet)
-        return;
-      this._staleStyleSheets.add(sheet);
-      if (sheet.href !== null)
-        this._modifiedStyleSheets.add(sheet);
-    }
-
     private _updateStyleElementStyleSheetTextIfNeeded(sheet: CSSStyleSheet, forceText?: boolean): string | undefined {
-      const data = ensureCachedData(sheet);
-      if (this._staleStyleSheets.has(sheet) || (forceText && data.cssText === undefined)) {
-        this._staleStyleSheets.delete(sheet);
-        try {
-          data.cssText = this._getSheetText(sheet);
-        } catch (e) {
-          // Sometimes we cannot access cross-origin stylesheets.
-          data.cssText = '';
-        }
-      }
-      return data.cssText;
+
+      		const data = ensureCachedData(sheet);
+      		try {
+      			data.cssText = this._getSheetText(sheet);
+      		} catch (e) {
+      			data.cssText = '';
+      		}
+      		return data.cssText;
+      	
     }
 
     // Returns either content, ref, or no override.
     private _updateLinkStyleSheetTextIfNeeded(sheet: CSSStyleSheet, snapshotNumber: number): string | number | undefined {
-      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) {
-          // Sometimes we cannot access cross-origin stylesheets.
-        }
-      }
-      return data.cssRef === undefined ? undefined : snapshotNumber - data.cssRef;
+
+      		const data = ensureCachedData(sheet);
+      		try {
+      			const currentText = this._getSheetText(sheet);
+      			if (data.cssText === undefined) {
+      				data.cssText = currentText;
+      				return undefined;
+      			}
+      			if (currentText === data.cssText)
+      				return data.cssRef === undefined ? undefined : snapshotNumber - data.cssRef;
+      			data.cssText = currentText;
+      			data.cssRef = snapshotNumber;
+      			return data.cssText;
+      		} catch (e) {
+      			return undefined;
+      		}
+      	
     }
 
     markIframe(iframeElement: HTMLIFrameElement | HTMLFrameElement, frameId: string) {
@@ -256,8 +199,6 @@
     }
 
     reset() {
-      this._staleStyleSheets.clear();
-
       const visitNode = (node: Node | ShadowRoot) => {
         resetCachedData(node);
         if (node.nodeType === Node.ELEMENT_NODE) {
@@ -326,17 +267,12 @@
     }
 
     private _getSheetText(sheet: CSSStyleSheet): string {
-      this._readingStyleSheet = true;
-      try {
-        if (sheet.disabled)
-          return '';
-        const rules: string[] = [];
-        for (const rule of sheet.cssRules)
-          rules.push(rule.cssText);
-        return rules.join('\n');
-      } finally {
-        this._readingStyleSheet = false;
-      }
+
+      		const rules: string[] = [];
+      		for (const rule of sheet.cssRules)
+      			rules.push(rule.cssText);
+      		return rules.join('\n');
+      	
     }
 
     captureSnapshot(needsReset: boolean): SnapshotData | undefined {
@@ -635,18 +571,18 @@
         collectionTime: 0,
       };
 
-      for (const sheet of this._modifiedStyleSheets) {
-        if (sheet.href === null)
-          continue;
-        const content = this._updateLinkStyleSheetTextIfNeeded(sheet, snapshotNumber);
-        if (content === undefined) {
-          // Unable to capture stylesheet contents.
-          continue;
-        }
-        const base = this._getSheetBase(sheet);
-        const url = removeHash(this._resolveUrl(base, sheet.href!));
-        result.resourceOverrides.push({ url, content, contentType: 'text/css' },);
-      }
+      for (const sheet of document.styleSheets) {
+              if (sheet.href === null)
+                continue;
+              const content = this._updateLinkStyleSheetTextIfNeeded(sheet, snapshotNumber);
+              if (content === undefined) {
+                // Unable to capture stylesheet contents.
+                continue;
+              }
+              const base = this._getSheetBase(sheet);
+              const url = removeHash(this._resolveUrl(base, sheet.href!));
+              result.resourceOverrides.push({ url, content, contentType: 'text/css' },);
+            }
 
       result.collectionTime = performance.now() - timestamp;
       return result;
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/trace/recorder/tracing.ts patchright/node_modules/playwright-core/src/server/trace/recorder/tracing.ts
---
+++
@@ -670,6 +670,11 @@
 }
 
 function createBeforeActionTraceEvent(metadata: CallMetadata, parentId?: string): trace.BeforeActionTraceEvent | null {
+
+  				// Filter out internal fallback Route.continue calls from Patchright's inject routing
+  				if (metadata.type === 'Route' && metadata.method === 'continue' && metadata.params?.isFallback)
+  					return null;
+  			
   if (metadata.internal || metadata.method.startsWith('tracing'))
     return null;
   const event: trace.BeforeActionTraceEvent = {
@@ -689,6 +694,11 @@
 }
 
 function createInputActionTraceEvent(metadata: CallMetadata): trace.InputActionTraceEvent | null {
+
+  				// Filter out internal fallback Route.continue calls from Patchright's inject routing
+  				if (metadata.type === 'Route' && metadata.method === 'continue' && metadata.params?.isFallback)
+  					return null;
+  			
   if (metadata.internal || metadata.method.startsWith('tracing'))
     return null;
   return {
@@ -699,6 +709,11 @@
 }
 
 function createActionLogTraceEvent(metadata: CallMetadata, message: string): trace.LogTraceEvent | null {
+
+  				// Filter out internal fallback Route.continue calls from Patchright's inject routing
+  				if (metadata.type === 'Route' && metadata.method === 'continue' && metadata.params?.isFallback)
+  					return null;
+  			
   if (metadata.internal || metadata.method.startsWith('tracing'))
     return null;
   return {
@@ -710,6 +725,11 @@
 }
 
 function createAfterActionTraceEvent(metadata: CallMetadata): trace.AfterActionTraceEvent | null {
+
+  				// Filter out internal fallback Route.continue calls from Patchright's inject routing
+  				if (metadata.type === 'Route' && metadata.method === 'continue' && metadata.params?.isFallback)
+  					return null;
+  			
   if (metadata.internal || metadata.method.startsWith('tracing'))
     return null;
   return {
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/server/utils/expectUtils.ts patchright/node_modules/playwright-core/src/server/utils/expectUtils.ts
---
+++
@@ -116,8 +116,7 @@
     details.printedDiff = undefined;
   }
 
-  const align = !details.errorMessage && details.printedExpected?.startsWith('Expected:')
-      && (!details.printedReceived || details.printedReceived.startsWith('Received:'));
+  const align = !details.errorMessage && details.printedExpected?.startsWith('Expected:') && (!details.printedReceived || details.printedReceived.startsWith('Received:'));
   if (details.locator)
     message += `Locator: ${align ? ' ' : ''}${details.locator}\n`;
   if (details.printedExpected)
diff -ruN -x protocol.yml --minimal playwright/node_modules/playwright-core/src/utils/isomorphic/oldUtilityScriptSerializers.ts patchright/node_modules/playwright-core/src/utils/isomorphic/oldUtilityScriptSerializers.ts
---
+++
@@ -0,0 +1,292 @@
+;
+		/**
+		 * Copyright (c) Microsoft Corporation.
+		 *
+		 * Licensed under the Apache License, Version 2.0 (the "License");
+		 * you may not use this file except in compliance with the License.
+		 * You may obtain a copy of the License at
+		 *
+		 * http://www.apache.org/licenses/LICENSE-2.0
+		 *
+		 * Unless required by applicable law or agreed to in writing, software
+		 * distributed under the License is distributed on an "AS IS" BASIS,
+		 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+		 * See the License for the specific language governing permissions and
+		 * limitations under the License.
+		 */
+
+		type TypedArrayKind = 'i8' | 'ui8' | 'ui8c' | 'i16' | 'ui16' | 'i32' | 'ui32' | 'f32' | 'f64' | 'bi64' | 'bui64';
+
+		export type SerializedValue =
+				undefined | boolean | number | string |
+				{ v: 'null' | 'undefined' | 'NaN' | 'Infinity' | '-Infinity' | '-0' } |
+				{ d: string } |
+				{ u: string } |
+				{ bi: string } |
+				{ e: { n: string, m: string, s: string } } |
+				{ r: { p: string, f: string } } |
+				{ a: SerializedValue[], id: number } |
+				{ o: { k: string, v: SerializedValue }[], id: number } |
+				{ ref: number } |
+				{ h: number } |
+				{ ta: { b: string, k: TypedArrayKind } };
+
+		type HandleOrValue = { h: number } | { fallThrough: any };
+
+		type VisitorInfo = {
+			visited: Map<object, number>;
+			lastId: number;
+		};
+
+		export function source() {
+
+			function isRegExp(obj: any): obj is RegExp {
+				try {
+					return obj instanceof RegExp || Object.prototype.toString.call(obj) === '[object RegExp]';
+				} catch (error) {
+					return false;
+				}
+			}
+
+			function isDate(obj: any): obj is Date {
+				try {
+					return obj instanceof Date || Object.prototype.toString.call(obj) === '[object Date]';
+				} catch (error) {
+					return false;
+				}
+			}
+
+			function isURL(obj: any): obj is URL {
+				try {
+					return obj instanceof URL || Object.prototype.toString.call(obj) === '[object URL]';
+				} catch (error) {
+					return false;
+				}
+			}
+
+			function isError(obj: any): obj is Error {
+				try {
+					return obj instanceof Error || (obj && Object.getPrototypeOf(obj)?.name === 'Error');
+				} catch (error) {
+					return false;
+				}
+			}
+
+			function isTypedArray(obj: any, constructor: Function): boolean {
+				try {
+					return obj instanceof constructor || Object.prototype.toString.call(obj) === `[object ${constructor.name}]`;
+				} catch (error) {
+					return false;
+				}
+			}
+
+			const typedArrayConstructors: Record<TypedArrayKind, Function> = {
+				i8: Int8Array,
+				ui8: Uint8Array,
+				ui8c: Uint8ClampedArray,
+				i16: Int16Array,
+				ui16: Uint16Array,
+				i32: Int32Array,
+				ui32: Uint32Array,
+				// TODO: add Float16Array once it's in baseline
+				f32: Float32Array,
+				f64: Float64Array,
+				bi64: BigInt64Array,
+				bui64: BigUint64Array,
+			};
+
+			function typedArrayToBase64(array: any) {
+				/**
+				 * Firefox does not support iterating over typed arrays, so we use `.toBase64`.
+				 * Error: 'Accessing TypedArray data over Xrays is slow, and forbidden in order to encourage performant code. To copy TypedArrays across origin boundaries, consider using Components.utils.cloneInto().'
+				 */
+				if ('toBase64' in array)
+					return array.toBase64();
+				const binary = Array.from(new Uint8Array(array.buffer, array.byteOffset, array.byteLength)).map(b => String.fromCharCode(b)).join('');
+				return btoa(binary);
+			}
+
+			function base64ToTypedArray(base64: string, TypedArrayConstructor: any) {
+				const binary = atob(base64);
+				const bytes = new Uint8Array(binary.length);
+				for (let i = 0; i < binary.length; i++)
+					bytes[i] = binary.charCodeAt(i);
+				return new TypedArrayConstructor(bytes.buffer);
+			}
+
+			function parseEvaluationResultValue(value: SerializedValue, handles: any[] = [], refs: Map<number, object> = new Map()): any {
+				if (Object.is(value, undefined))
+					return undefined;
+				if (typeof value === 'object' && value) {
+					if ('ref' in value)
+						return refs.get(value.ref);
+					if ('v' in value) {
+						if (value.v === 'undefined')
+							return undefined;
+						if (value.v === 'null')
+							return null;
+						if (value.v === 'NaN')
+							return NaN;
+						if (value.v === 'Infinity')
+							return Infinity;
+						if (value.v === '-Infinity')
+							return -Infinity;
+						if (value.v === '-0')
+							return -0;
+						return undefined;
+					}
+					if ('d' in value)
+						return new Date(value.d);
+					if ('u' in value)
+						return new URL(value.u);
+					if ('bi' in value)
+						return BigInt(value.bi);
+					if ('e' in value) {
+						const error = new Error(value.e.m);
+						error.name = value.e.n;
+						error.stack = value.e.s;
+						return error;
+					}
+					if ('r' in value)
+						return new RegExp(value.r.p, value.r.f);
+					if ('a' in value) {
+						const result: any[] = [];
+						refs.set(value.id, result);
+						for (const a of value.a)
+							result.push(parseEvaluationResultValue(a, handles, refs));
+						return result;
+					}
+					if ('o' in value) {
+						const result: any = {};
+						refs.set(value.id, result);
+						for (const { k, v } of value.o)
+							result[k] = parseEvaluationResultValue(v, handles, refs);
+						return result;
+					}
+					if ('h' in value)
+						return handles[value.h];
+					if ('ta' in value)
+						return base64ToTypedArray(value.ta.b, typedArrayConstructors[value.ta.k]);
+				}
+				return value;
+			}
+
+			function serializeAsCallArgument(value: any, handleSerializer: (value: any) => HandleOrValue): SerializedValue {
+				return serialize(value, handleSerializer, { visited: new Map(), lastId: 0 });
+			}
+
+			function serialize(value: any, handleSerializer: (value: any) => HandleOrValue, visitorInfo: VisitorInfo): SerializedValue {
+				if (value && typeof value === 'object') {
+					// eslint-disable-next-line no-restricted-globals
+					if (typeof globalThis.Window === 'function' && value instanceof globalThis.Window)
+						return 'ref: <Window>';
+					// eslint-disable-next-line no-restricted-globals
+					if (typeof globalThis.Document === 'function' && value instanceof globalThis.Document)
+						return 'ref: <Document>';
+					// eslint-disable-next-line no-restricted-globals
+					if (typeof globalThis.Node === 'function' && value instanceof globalThis.Node)
+						return 'ref: <Node>';
+				}
+				return innerSerialize(value, handleSerializer, visitorInfo);
+			}
+
+			function innerSerialize(value: any, handleSerializer: (value: any) => HandleOrValue, visitorInfo: VisitorInfo): SerializedValue {
+				const result = handleSerializer(value);
+				if ('fallThrough' in result)
+					value = result.fallThrough;
+				else
+					return result;
+
+				if (typeof value === 'symbol')
+					return { v: 'undefined' };
+				if (Object.is(value, undefined))
+					return { v: 'undefined' };
+				if (Object.is(value, null))
+					return { v: 'null' };
+				if (Object.is(value, NaN))
+					return { v: 'NaN' };
+				if (Object.is(value, Infinity))
+					return { v: 'Infinity' };
+				if (Object.is(value, -Infinity))
+					return { v: '-Infinity' };
+				if (Object.is(value, -0))
+					return { v: '-0' };
+
+				if (typeof value === 'boolean')
+					return value;
+				if (typeof value === 'number')
+					return value;
+				if (typeof value === 'string')
+					return value;
+				if (typeof value === 'bigint')
+					return { bi: value.toString() };
+
+				if (isError(value)) {
+					let stack;
+					if (value.stack?.startsWith(value.name + ': ' + value.message)) {
+						// v8
+						stack = value.stack;
+					} else {
+						stack = `${value.name}: ${value.message}
+${value.stack}`;
+					}
+					return { e: { n: value.name, m: value.message, s: stack } };
+				}
+				if (isDate(value))
+					return { d: value.toJSON() };
+				if (isURL(value))
+					return { u: value.toJSON() };
+				if (isRegExp(value))
+					return { r: { p: value.source, f: value.flags } };
+				for (const [k, ctor] of Object.entries(typedArrayConstructors) as [TypedArrayKind, Function][]) {
+					if (isTypedArray(value, ctor))
+						return { ta: { b: typedArrayToBase64(value), k } };
+				}
+
+				const id = visitorInfo.visited.get(value);
+				if (id)
+					return { ref: id };
+
+				if (Array.isArray(value)) {
+					const a = [];
+					const id = ++visitorInfo.lastId;
+					visitorInfo.visited.set(value, id);
+					for (let i = 0; i < value.length; ++i)
+						a.push(serialize(value[i], handleSerializer, visitorInfo));
+					return { a, id };
+				}
+
+				if (typeof value === 'object') {
+					const o: { k: string, v: SerializedValue }[] = [];
+					const id = ++visitorInfo.lastId;
+					visitorInfo.visited.set(value, id);
+					for (const name of Object.keys(value)) {
+						let item;
+						try {
+							item = value[name];
+						} catch (e) {
+							continue;  // native bindings will throw sometimes;
+						}
+						if (name === 'toJSON' && typeof item === 'function')
+							o.push({ k: name, v: { o: [], id: 0 } });
+						else
+							o.push({ k: name, v: serialize(item, handleSerializer, visitorInfo) });
+					}
+
+					let jsonWrapper;
+					try {
+						// If Object.keys().length === 0 we fall back to toJSON if it exists
+						if (o.length === 0 && value.toJSON && typeof value.toJSON === 'function')
+							jsonWrapper = { value: value.toJSON() };
+					} catch (e) {
+					}
+					if (jsonWrapper)
+						return innerSerialize(jsonWrapper.value, handleSerializer, visitorInfo);
+
+					return { o, id };
+				}
+			}
+
+			return { parseEvaluationResultValue, serializeAsCallArgument };
+		}
+	
\ No newline at end of file
diff -ruN -x protocol.yml --minimal playwright/node_modules/recorder/src/recorder.tsx patchright/node_modules/recorder/src/recorder.tsx
---
+++
@@ -101,7 +101,7 @@
   }, [backend, mode, selectedTab, setSelectedTab, source]);
 
   React.useEffect(() => {
-    backend.setAutoExpect({ autoExpect });
+    try { window.dispatch({ event: 'setAutoExpect', params: { autoExpect } }); } catch {}		
   }, [autoExpect, backend]);
 
   React.useLayoutEffect(() => {
diff -ruN -x protocol.yml --minimal playwright/packages/injected/src/xpathSelectorEngine.ts patchright/packages/injected/src/xpathSelectorEngine.ts
---
+++
@@ -18,6 +18,43 @@
 
 export const XPathEngine: SelectorEngine = {
   queryAll(root: SelectorRoot, selector: string): Element[] {
+
+    		if (root.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+    			const result: Element[] = [];
+    			// Custom ClosedShadowRoot XPath Engine
+    			const parser = new DOMParser();
+    			// Function to (recursively) get all elements in the shadowRoot
+    			function getAllChildElements(node) {
+    				const elements = [];
+    				const traverse = (currentNode) => {
+    					if (currentNode.nodeType === Node.ELEMENT_NODE) elements.push(currentNode);
+    					currentNode.childNodes?.forEach(traverse);
+    				};
+    				if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.ELEMENT_NODE) {
+    					traverse(node);
+    				}
+    				return elements;
+    			}
+    			// Setting innerHTMl and childElements (all, recursive) to avoid race conditions
+    			const csrHTMLContent = root.innerHTML;
+    			const csrChildElements = getAllChildElements(root);
+    			const htmlDoc = parser.parseFromString(csrHTMLContent, 'text/html');
+    			const rootDiv = htmlDoc.body;
+    			const rootDivChildElements = getAllChildElements(rootDiv);
+    			// Use the namespace prefix in the XPath expression
+    			const it = htmlDoc.evaluate(selector, htmlDoc, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE);
+    			for (let node = it.iterateNext(); node; node = it.iterateNext()) {
+    				// -1 for the body element
+    				const nodeIndex = rootDivChildElements.indexOf(node) - 1;
+    				if (nodeIndex >= 0) {
+    					const originalNode = csrChildElements[nodeIndex];
+    					if (originalNode.nodeType === Node.ELEMENT_NODE)
+    						result.push(originalNode as Element);
+    				}
+    			}
+    			return result;
+    		}
+    	
     if (selector.startsWith('/') && root.nodeType !== Node.DOCUMENT_NODE)
       selector = '.' + selector;
     const result: Element[] = [];
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/cli/program.ts patchright/packages/playwright-core/src/cli/program.ts
---
+++
@@ -1,21 +1,3 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable no-console */
-
 import '../bootstrap';
 import { gracefullyProcessExitDoNotHang, getPackageManagerExecCommand } from '../utils';
 import { addTraceCommands } from '../tools/trace/traceCli';
@@ -69,10 +51,10 @@
 
 program
     .command('install [browser...]')
-    .description('ensure browsers necessary for this version of Playwright are installed')
+    .description('ensure browsers necessary for this version of Patchright are installed')
     .option('--with-deps', 'install system dependencies for browsers')
     .option('--dry-run', 'do not execute installation, only print information')
-    .option('--list', 'prints list of browsers from all playwright installations')
+    .option('--list', 'prints list of browsers from all patchright installations')
     .option('--force', 'force reinstall of already installed browsers')
     .option('--only-shell', 'only install headless shell when installing chromium')
     .option('--no-shell', 'do not install chromium headless shell')
@@ -95,8 +77,8 @@
 
 program
     .command('uninstall')
-    .description('Removes browsers used by this installation of Playwright from the system (chromium, firefox, webkit, ffmpeg). This does not include branded channels.')
-    .option('--all', 'Removes all browsers used by any Playwright installation from the system.')
+    .description('Removes browsers used by this installation of Patchright from the system (chromium, firefox, webkit, ffmpeg). This does not include branded channels.')
+    .option('--all', 'Removes all browsers used by any Patchright installation from the system.')
     .action(async (options: { all?: boolean }) => {
       const { uninstallBrowsers } = await import('./installActions');
       uninstallBrowsers(options).catch(logErrorAndExit);
@@ -284,7 +266,7 @@
       .option('--save-har-glob <glob pattern>', 'filter entries in the HAR by matching url against this glob pattern')
       .option('--save-storage <filename>', 'save context storage state at the end, for later use with --load-storage')
       .option('--timezone <time zone>', 'time zone to emulate, for example "Europe/Rome"')
-      .option('--timeout <timeout>', 'timeout for Playwright actions in milliseconds, no timeout by default')
+      .option('--timeout <timeout>', 'timeout for Patchright actions in milliseconds, no timeout by default')
       .option('--user-agent <ua string>', 'specify user agent string')
       .option('--user-data-dir <directory>', 'use the specified user data directory instead of a new context')
       .option('--viewport-size <size>', 'specify browser viewport size in pixels, for example "1280, 720"');
@@ -293,14 +275,14 @@
 function buildBasePlaywrightCLICommand(cliTargetLang: string | undefined): string {
   switch (cliTargetLang) {
     case 'python':
-      return `playwright`;
+      return `patchright`;
     case 'java':
       return `mvn exec:java -e -D exec.mainClass=com.microsoft.playwright.CLI -D exec.args="...options.."`;
     case 'csharp':
       return `pwsh bin/Debug/netX/playwright.ps1`;
     default: {
       const packageManagerCommand = getPackageManagerExecCommand();
-      return `${packageManagerCommand} playwright`;
+      return `${packageManagerCommand} patchright`;
     }
   }
 }
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/cli/programWithTestStub.ts patchright/packages/playwright-core/src/cli/programWithTestStub.ts
---
+++
@@ -1,21 +1,3 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable no-console */
-
 import { gracefullyProcessExitDoNotHang } from '../server/utils/processLauncher';
 import { getPackageManager } from '../utils';
 import { program } from './program';
@@ -34,24 +16,24 @@
     packages.push('playwright');
   const packageManager = getPackageManager();
   if (packageManager === 'yarn') {
-    console.error(`Please install @playwright/test package before running "yarn playwright ${command}"`);
+    console.error(`Please install @playwright/test package before running "yarn patchright ${command}"`);
     console.error(`  yarn remove ${packages.join(' ')}`);
     console.error('  yarn add -D @playwright/test');
   } else if (packageManager === 'pnpm') {
-    console.error(`Please install @playwright/test package before running "pnpm exec playwright ${command}"`);
+    console.error(`Please install @playwright/test package before running "pnpm exec patchright ${command}"`);
     console.error(`  pnpm remove ${packages.join(' ')}`);
     console.error('  pnpm add -D @playwright/test');
   } else {
-    console.error(`Please install @playwright/test package before running "npx playwright ${command}"`);
+    console.error(`Please install @playwright/test package before running "npx patchright ${command}"`);
     console.error(`  npm uninstall ${packages.join(' ')}`);
     console.error('  npm install -D @playwright/test');
   }
 }
 
 const kExternalPlaywrightTestCommands = [
-  ['test', 'Run tests with Playwright Test.'],
-  ['show-report', 'Show Playwright Test HTML report.'],
-  ['merge-reports', 'Merge Playwright Test Blob reports'],
+  ['test', 'Run tests with Patchright Test.'],
+  ['show-report', 'Show Patchright Test HTML report.'],
+  ['merge-reports', 'Merge Patchright Test Blob reports'],
 ];
 function addExternalPlaywrightTestCommands() {
   for (const [command, description] of kExternalPlaywrightTestCommands) {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/client/browserContext.ts patchright/packages/playwright-core/src/client/browserContext.ts
---
+++
@@ -146,9 +146,9 @@
         // a) removing "dialog" listener subscription (client->server)
         // b) actual "dialog" event (server->client)
         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), Page.fromNullable(page)));
@@ -356,17 +356,20 @@
   }
 
   async addInitScript(script: Function | string | { path?: string, content?: string }, arg?: any) {
+    await this.installInjectRoute();
     const source = await evaluationScript(this._platform, script, arg);
     return DisposableObject.from((await this._channel.addInitScript({ source })).disposable);
   }
 
   async exposeBinding(name: string, callback: (source: structs.BindingSource, ...args: any[]) => any, options: { handle?: boolean } = {}): Promise<DisposableObject> {
+    await this.installInjectRoute();
     const result = await this._channel.exposeBinding({ name, needsHandle: options.handle });
     this._bindings.set(name, callback);
     return DisposableObject.from(result.disposable);
   }
 
   async exposeFunction(name: string, callback: Function): Promise<DisposableObject> {
+    await this.installInjectRoute();
     const result = await this._channel.exposeBinding({ name });
     const binding = (source: structs.BindingSource, ...args: any[]) => callback(...args);
     this._bindings.set(name, binding);
@@ -560,6 +563,25 @@
     await this._channel.exposeConsoleApi();
   }
 
+  routeInjecting: boolean = false;
+
+  async installInjectRoute() {
+
+      if (this.routeInjecting) return;
+        await this.route('**/*', async route => {
+        try {
+            if (route.request().resourceType() === 'document' && route.request().url().startsWith('http')) {
+                const protocol = route.request().url().split(':')[0];
+                await route.fallback({ url: protocol + '://patchright-init-script-inject.internal/' });
+            } else {
+                await route.fallback();
+            }
+        } catch (error) {
+            await route.fallback();
+        }
+      });
+      this.routeInjecting = true;
+  }
 }
 
 async function prepareStorageState(platform: Platform, storageState: string | SetStorageState): Promise<NonNullable<channels.BrowserNewContextParams['storageState']>> {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/client/clientHelper.ts patchright/packages/playwright-core/src/client/clientHelper.ts
---
+++
@@ -50,5 +50,5 @@
 }
 
 export function addSourceUrlToScript(source: string, path: string): string {
-  return `${source}\n//# sourceURL=${path.replace(/\n/g, '')}`;
+  return source
 }
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/client/clock.ts patchright/packages/playwright-core/src/client/clock.ts
---
+++
@@ -25,6 +25,7 @@
   }
 
   async install(options: { time?: number | string | Date } = { }) {
+    await this._browserContext.installInjectRoute()
     await this._browserContext._channel.clockInstall(options.time !== undefined ? parseTime(options.time) : {});
   }
 
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/client/frame.ts patchright/packages/playwright-core/src/client/frame.ts
---
+++
@@ -177,25 +177,33 @@
   }
 
   async waitForURL(url: URLMatch, options: { waitUntil?: LifecycleEvent, timeout?: number } = {}): Promise<void> {
-    if (urlMatches(this._page?.context()._options.baseURL, this.url(), url))
-      return await this.waitForLoadState(options.waitUntil, options);
 
-    await this.waitForNavigation({ url, ...options });
+      if (urlMatches(this._page?.context()._options.baseURL, this.url(), url))
+        return await this.waitForLoadState(options.waitUntil, options);
+      try {
+        await this.waitForNavigation({ url, ...options });
+      } catch (error) {
+        if (urlMatches(this._page?.context()._options.baseURL, this.url(), url)) {
+          await this.waitForLoadState(options.waitUntil, options);
+          return;
+        }
+        throw error;
+      }
   }
 
   async frameElement(): Promise<ElementHandle> {
     return ElementHandle.from((await this._channel.frameElement()).element);
   }
 
-  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<structs.SmartHandle<R>> {
-    assertMaxArguments(arguments.length, 2);
-    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
+  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<structs.SmartHandle<R>> {
+    assertMaxArguments(arguments.length, 3);
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
     return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
   }
 
-  async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<R> {
-    assertMaxArguments(arguments.length, 2);
-    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
+  async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<R> {
+    assertMaxArguments(arguments.length, 3);
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
     return parseResult(result.value);
   }
 
@@ -231,9 +239,9 @@
     return parseResult(result.value);
   }
 
-  async $$eval<R, Arg>(selector: string, pageFunction: structs.PageFunctionOn<Element[], Arg, R>, arg?: Arg): Promise<R> {
-    assertMaxArguments(arguments.length, 3);
-    const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
+  async $$eval<R, Arg>(selector: string, pageFunction: structs.PageFunctionOn<Element[], Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<R> {
+    assertMaxArguments(arguments.length, 4);
+    const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
     return parseResult(result.value);
   }
 
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/client/jsHandle.ts patchright/packages/playwright-core/src/client/jsHandle.ts
---
+++
@@ -36,14 +36,16 @@
     this._channel.on('previewUpdated', ({ preview }) => this._preview = preview);
   }
 
-  async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg): Promise<R> {
-    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
-    return parseResult(result.value);
+  async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<R> {
+
+      const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
+      return parseResult(result.value);
   }
 
-  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg): Promise<structs.SmartHandle<R>> {
-    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
-    return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
+  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<structs.SmartHandle<R>> {
+
+      const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
+      return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
   }
 
   async getProperty(propertyName: string): Promise<JSHandle> {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/client/locator.ts patchright/packages/playwright-core/src/client/locator.ts
---
+++
@@ -1,3 +1,5 @@
+// undetected-undetected_playwright-patch - custom imports
+import { JSHandle, parseResult, serializeArgument } from './jsHandle';
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -124,16 +126,52 @@
     });
   }
 
-  async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<SVGElement | HTMLElement, Arg, R>, arg?: Arg, options?: TimeoutOptions): Promise<R> {
-    return await this._withElement(h => h.evaluate(pageFunction, arg), { title: 'Evaluate', timeout: options?.timeout });
+  async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<SVGElement | HTMLElement, Arg, R>, arg?: Arg, options?: TimeoutOptions, isolatedContext: boolean = true): Promise<R> {
+
+      if (typeof options === 'boolean') {
+        isolatedContext = options;
+        options = undefined;
+      }
+      return await this._withElement(
+        async (h) =>
+          parseResult(
+            (
+              await h._channel.evaluateExpression({
+                expression: String(pageFunction),
+                isFunction: typeof pageFunction === "function",
+                arg: serializeArgument(arg),
+                isolatedContext: isolatedContext,
+              })
+            ).value
+          ),
+        { title: "Evaluate", timeout: options?.timeout }
+      );
   }
 
-  async evaluateAll<R, Arg>(pageFunction: structs.PageFunctionOn<Element[], Arg, R>, arg?: Arg): Promise<R> {
-    return await this._frame.$$eval(this._selector, pageFunction, arg);
+  async evaluateAll<R, Arg>(pageFunction: structs.PageFunctionOn<Element[], Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<R> {
+    return await this._frame.$$eval(this._selector, pageFunction, arg, isolatedContext);
   }
 
-  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<any, Arg, R>, arg?: Arg, options?: TimeoutOptions): Promise<structs.SmartHandle<R>> {
-    return await this._withElement(h => h.evaluateHandle(pageFunction, arg), { title: 'Evaluate', timeout: options?.timeout });
+  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<any, Arg, R>, arg?: Arg, options?: TimeoutOptions, isolatedContext: boolean = true): Promise<structs.SmartHandle<R>> {
+
+      if (typeof options === 'boolean') {
+        isolatedContext = options;
+        options = undefined;
+      }
+      return await this._withElement(
+        async (h) =>
+          JSHandle.from(
+            (
+              await h._channel.evaluateExpressionHandle({
+                expression: String(pageFunction),
+                isFunction: typeof pageFunction === "function",
+                arg: serializeArgument(arg),
+                isolatedContext: isolatedContext,
+              })
+            ).handle
+          ) as any as structs.SmartHandle<R>,
+        { title: "Evaluate", timeout: options?.timeout }
+      );
   }
 
   async fill(value: string, options: channels.ElementHandleFillOptions & TimeoutOptions = {}): Promise<void> {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/client/network.ts patchright/packages/playwright-core/src/client/network.ts
---
+++
@@ -15,7 +15,7 @@
  */
 
 import { ChannelOwner } from './channelOwner';
-import { isTargetClosedError } from './errors';
+import { isTargetClosedError, TargetClosedError } from './errors';
 import { Events } from './events';
 import { APIResponse } from './fetch';
 import { Frame } from './frame';
@@ -183,7 +183,12 @@
   }
 
   async allHeaders(): Promise<Headers> {
-    return (await this._actualHeaders()).headers();
+
+      const headers = await this._actualHeaders();
+      const page = this._safePage();
+      if (page?._closeWasCalled)
+        throw new TargetClosedError();
+      return headers.headers();
   }
 
   async headersArray(): Promise<HeadersArray> {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/client/page.ts patchright/packages/playwright-core/src/client/page.ts
---
+++
@@ -313,9 +313,9 @@
     return await this._mainFrame.dispatchEvent(selector, type, eventInit, options);
   }
 
-  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<structs.SmartHandle<R>> {
-    assertMaxArguments(arguments.length, 2);
-    return await this._mainFrame.evaluateHandle(pageFunction, arg);
+  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<structs.SmartHandle<R>> {
+    assertMaxArguments(arguments.length, 3);
+    return await this._mainFrame.evaluateHandle(pageFunction, arg, isolatedContext);
   }
 
   async $eval<R, Arg>(selector: string, pageFunction: structs.PageFunctionOn<Element, Arg, R>, arg?: Arg): Promise<R> {
@@ -341,6 +341,7 @@
   }
 
   async exposeFunction(name: string, callback: Function) {
+    await this.installInjectRoute();
     const result = await this._channel.exposeBinding({ name });
     const binding = (source: structs.BindingSource, ...args: any[]) => callback(...args);
     this._bindings.set(name, binding);
@@ -348,6 +349,7 @@
   }
 
   async exposeBinding(name: string, callback: (source: structs.BindingSource, ...args: any[]) => any, options: { handle?: boolean } = {}) {
+    await this.installInjectRoute();
     const result = await this._channel.exposeBinding({ name, needsHandle: options.handle });
     this._bindings.set(name, callback);
     return DisposableObject.from(result.disposable);
@@ -507,12 +509,13 @@
     return this._viewportSize || null;
   }
 
-  async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<R> {
-    assertMaxArguments(arguments.length, 2);
-    return await this._mainFrame.evaluate(pageFunction, arg);
+  async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<R> {
+    assertMaxArguments(arguments.length, 3);
+    return await this._mainFrame.evaluate(pageFunction, arg, isolatedContext);
   }
 
   async addInitScript(script: Function | string | { path?: string, content?: string }, arg?: any) {
+    await this.installInjectRoute();
     const source = await evaluationScript(this._platform, script, arg);
     return DisposableObject.from((await this._channel.addInitScript({ source })).disposable);
   }
@@ -864,6 +867,26 @@
   async _setDockTile(image: Buffer) {
     await this._channel.setDockTile({ image });
   }
+
+  routeInjecting: boolean = false;
+
+  async installInjectRoute() {
+
+      if (this.routeInjecting || this.context().routeInjecting) return;
+      await this.route('**/*', async route => {
+        try {
+          if (route.request().resourceType() === 'document' && route.request().url().startsWith('http')) {
+              const protocol = route.request().url().split(':')[0];
+              await route.fallback({ url: protocol + '://patchright-init-script-inject.internal/' });
+          } else {
+              await route.fallback();
+          }
+      } catch (error) {
+          await route.fallback();
+        }
+      });
+      this.routeInjecting = true;
+  }
 }
 
 export class BindingCall extends ChannelOwner<channels.BindingCallChannel> {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/client/tracing.ts patchright/packages/playwright-core/src/client/tracing.ts
---
+++
@@ -38,6 +38,7 @@
   }
 
   async start(options: { name?: string, title?: string, snapshots?: boolean, screenshots?: boolean, sources?: boolean, live?: boolean } = {}) {
+    if (typeof this._parent.installInjectRoute === 'function') await this._parent.installInjectRoute();
     await this._wrapApiCall(async () => {
       this._includeSources = !!options.sources;
       this._isLive = !!options.live;
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/client/worker.ts patchright/packages/playwright-core/src/client/worker.ts
---
+++
@@ -62,15 +62,15 @@
     return this._initializer.url;
   }
 
-  async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<R> {
-    assertMaxArguments(arguments.length, 2);
-    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
+  async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<R> {
+    assertMaxArguments(arguments.length, 3);
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
     return parseResult(result.value);
   }
 
-  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<structs.SmartHandle<R>> {
-    assertMaxArguments(arguments.length, 2);
-    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
+  async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, isolatedContext: boolean = true): Promise<structs.SmartHandle<R>> {
+    assertMaxArguments(arguments.length, 3);
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg), isolatedContext: isolatedContext });
     return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
   }
 
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/android/android.ts patchright/packages/playwright-core/src/server/android/android.ts
---
+++
@@ -1,19 +1,3 @@
-/**
- * Copyright Microsoft Corporation. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 import { EventEmitter } from 'events';
 import fs from 'fs';
 import os from 'os';
@@ -184,7 +168,7 @@
       for (const file of ['android-driver.apk', 'android-driver-target.apk']) {
         const fullName = path.join(executable.directory!, file);
         if (!fs.existsSync(fullName))
-          throw new Error(`Please install Android driver apk using '${packageManagerCommand} playwright install android'`);
+          throw new Error(`Please install Android driver apk using '${packageManagerCommand} patchright install android'`);
         await this.installApk(progress, await progress.race(fs.promises.readFile(fullName)));
       }
     } else {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/browserContext.ts patchright/packages/playwright-core/src/server/browserContext.ts
---
+++
@@ -167,7 +167,7 @@
       await this.exposeConsoleApi();
 
     if (this._options.serviceWorkers === 'block')
-      await this.addInitScript(`\nif (navigator.serviceWorker) navigator.serviceWorker.register = async () => { console.warn('Service Worker registration blocked by Playwright'); };\n`);
+      await this.addInitScript(`if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { };`);
 
     if (this._options.permissions)
       await this.grantPermissions(this._options.permissions);
@@ -352,18 +352,13 @@
       if (page.getBinding(name))
         throw new Error(`Function "${name}" has been already registered in one of the pages`);
     }
-    await progress.race(this.exposePlaywrightBindingIfNeeded());
     const binding = new PageBinding(this, name, playwrightBinding, needsHandle);
     binding.forClient = forClient;
     this._pageBindings.set(name, binding);
-    try {
-      await progress.race(this.doAddInitScript(binding.initScript));
-      await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, 'main'));
-      return binding;
-    } catch (error) {
-      this._pageBindings.delete(name);
-      throw error;
-    }
+    
+    				await this.doExposeBinding(binding);
+    				return binding;
+    			
   }
 
   async removeExposedBinding(binding: PageBinding) {
@@ -881,4 +876,5 @@
   strictSelectors: false,
   serviceWorkers: 'allow',
   locale: 'en-US',
+  focusControl: false
 };
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/chromium/chromium.ts patchright/packages/playwright-core/src/server/chromium/chromium.ts
---
+++
@@ -320,8 +320,6 @@
     const chromeArguments = [...chromiumSwitches(options.assistantMode, options.channel)];
 
     // See https://issues.chromium.org/issues/40277080
-    chromeArguments.push('--enable-unsafe-swiftshader');
-
     if (options.headless) {
       chromeArguments.push('--headless');
 
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/chromium/chromiumSwitches.ts patchright/packages/playwright-core/src/server/chromium/chromiumSwitches.ts
---
+++
@@ -51,26 +51,16 @@
   '--disable-field-trial-config', // https://source.chromium.org/chromium/chromium/src/+/main:testing/variations/README.md
   '--disable-background-networking',
   '--disable-background-timer-throttling',
-  '--disable-backgrounding-occluded-windows',
-  '--disable-back-forward-cache', // Avoids surprises like main request not being intercepted during page.goBack().
-  '--disable-breakpad',
-  '--disable-client-side-phishing-detection',
-  '--disable-component-extensions-with-background-pages',
-  '--disable-component-update', // Avoids unneeded network activity after startup.
+  '--disable-backgrounding-occluded-windows', // Avoids surprises like main request not being intercepted during page.goBack().
+  '--disable-breakpad', // Avoids unneeded network activity after startup.
   '--no-default-browser-check',
-  '--disable-default-apps',
   '--disable-dev-shm-usage',
-  '--disable-extensions',
   '--disable-features=' + disabledFeatures(assistantMode).join(','),
   process.env.PLAYWRIGHT_LEGACY_SCREENSHOT ? '' : '--enable-features=CDPScreenshotNewSurface',
-  '--allow-pre-commit-input',
   '--disable-hang-monitor',
-  '--disable-ipc-flooding-protection',
-  '--disable-popup-blocking',
   '--disable-prompt-on-repost',
   '--disable-renderer-backgrounding',
   '--force-color-profile=srgb',
-  '--metrics-recording-only',
   '--no-first-run',
   '--password-store=basic',
   '--use-mock-keychain',
@@ -79,11 +69,8 @@
   '--export-tagged-pdf',
   // https://chromium-review.googlesource.com/c/chromium/src/+/4853540
   '--disable-search-engine-choice-screen',
-  // https://issues.chromium.org/41491762
-  '--unsafely-disable-devtools-self-xss-warnings',
   // Edge can potentially restart on Windows (msRelaunchNoCompatLayer) which looses its file descriptors (stdout/stderr) and CDP (3/4). Disable until fixed upstream.
   '--edge-skip-compat-layer-relaunch',
-  assistantMode ? '' : '--enable-automation',
   // This disables Chrome for Testing infobar that is visible in the persistent context.
   // The switch is ignored everywhere else, including Chromium/Chrome/Edge.
   '--disable-infobars',
@@ -91,4 +78,5 @@
   '--disable-search-engine-choice-screen',
   // Prevents the "three dots" menu crash in IdentityManager::HasPrimaryAccount for ephemeral contexts.
   android ? '' : '--disable-sync',
+  '--disable-blink-features=AutomationControlled'
 ].filter(Boolean);
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/chromium/crBrowser.ts patchright/packages/playwright-core/src/server/chromium/crBrowser.ts
---
+++
@@ -522,8 +522,10 @@
   }
 
   async doRemoveInitScripts(initScripts: InitScript[]) {
-    for (const page of this.pages())
-      await (page.delegate as CRPage).removeInitScripts(initScripts);
+
+    		for (const page of this.pages())
+    			await (page.delegate as CRPage).removeInitScripts(initScripts);
+    	
   }
 
   async doUpdateRequestInterception(): Promise<void> {
@@ -611,6 +613,20 @@
     const rootSession = await this._browser._clientRootSession();
     return rootSession.attachToTarget(targetId);
   }
+
+  async doExposeBinding(binding: PageBinding) {
+
+    		for (const page of this.pages())
+    			await (page.delegate as CRPage).exposeBinding(binding);
+    	
+  }
+
+  async doRemoveExposedBindings() {
+
+    		for (const page of this.pages())
+    			await (page.delegate as CRPage).removeExposedBindings();
+    	
+  }
 }
 
 export function shouldProxyLoopback(bypass: string | undefined) {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/chromium/crCoverage.ts patchright/packages/playwright-core/src/server/chromium/crCoverage.ts
---
+++
@@ -82,10 +82,13 @@
     this._scriptIds.clear();
     this._scriptSources.clear();
     this._eventListeners = [
-      eventsHelper.addEventListener(this._client, 'Debugger.scriptParsed', this._onScriptParsed.bind(this)),
-      eventsHelper.addEventListener(this._client, 'Runtime.executionContextsCleared', this._onExecutionContextsCleared.bind(this)),
-      eventsHelper.addEventListener(this._client, 'Debugger.paused', this._onDebuggerPaused.bind(this)),
-    ];
+          eventsHelper.addEventListener(this._client, 'Debugger.scriptParsed', this._onScriptParsed.bind(this)),
+          
+    						eventsHelper.addEventListener(this._client, 'Runtime.executionContextsCleared', this._onExecutionContextsCleared.bind(this)),
+    						eventsHelper.addEventListener(this._client, 'Page.frameNavigated', this._onFrameNavigated.bind(this)),
+    					
+          eventsHelper.addEventListener(this._client, 'Debugger.paused', this._onDebuggerPaused.bind(this)),
+        ];
     await Promise.all([
       this._client.send('Profiler.enable'),
       this._client.send('Profiler.startPreciseCoverage', { callCount: true, detailed: true }),
@@ -142,6 +145,11 @@
     }
     return coverage;
   }
+
+  _onFrameNavigated(event: Protocol.Page.frameNavigatedPayload) {
+    if (event.frame.parentId) return;
+    this._onExecutionContextsCleared();
+  }
 }
 
 class CSSCoverage {
@@ -169,9 +177,12 @@
     this._stylesheetURLs.clear();
     this._stylesheetSources.clear();
     this._eventListeners = [
-      eventsHelper.addEventListener(this._client, 'CSS.styleSheetAdded', this._onStyleSheet.bind(this)),
-      eventsHelper.addEventListener(this._client, 'Runtime.executionContextsCleared', this._onExecutionContextsCleared.bind(this)),
-    ];
+          eventsHelper.addEventListener(this._client, 'CSS.styleSheetAdded', this._onStyleSheet.bind(this)),
+          
+    						eventsHelper.addEventListener(this._client, 'Runtime.executionContextsCleared', this._onExecutionContextsCleared.bind(this)),
+    						eventsHelper.addEventListener(this._client, 'Page.frameNavigated', this._onFrameNavigated.bind(this)),
+    					
+        ];
     await Promise.all([
       this._client.send('DOM.enable'),
       this._client.send('CSS.enable'),
@@ -235,6 +246,11 @@
 
     return coverage;
   }
+
+  _onFrameNavigated(event: Protocol.Page.frameNavigatedPayload) {
+    if (event.frame.parentId) return;
+    this._onExecutionContextsCleared();
+  }
 }
 
 function convertToDisjointRanges(nestedRanges: {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/chromium/crDevTools.ts patchright/packages/playwright-core/src/server/chromium/crDevTools.ts
---
+++
@@ -64,7 +64,6 @@
       }).catch(e => null);
     });
     Promise.all([
-      session.send('Runtime.enable'),
       session.send('Runtime.addBinding', { name: kBindingName }),
       session.send('Page.enable'),
       session.send('Page.addScriptToEvaluateOnNewDocument', { source: `
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/chromium/crNetworkManager.ts patchright/packages/playwright-core/src/server/chromium/crNetworkManager.ts
---
+++
@@ -30,7 +30,7 @@
 import type * as types from '../types';
 import type { CRPage } from './crPage';
 import type { CRServiceWorker } from './crServiceWorker';
-
+import crypto from "crypto";
 
 type SessionInfo = {
   session: CRSession;
@@ -97,6 +97,7 @@
     if (info)
       eventsHelper.removeEventListeners(info.eventListeners);
     this._sessions.delete(session);
+    if (!this._sessions.size) this._alreadyTrackedNetworkIds.clear();
   }
 
   private async _forEachSession(cb: (sessionInfo: SessionInfo) => Promise<any>) {
@@ -142,6 +143,10 @@
   async setRequestInterception(value: boolean) {
     this._userRequestInterceptionEnabled = value;
     await this._updateProtocolRequestInterception();
+
+    			if (this._page)
+    				await this._forEachSession(info => info.session.send('Network.setCacheDisabled', { cacheDisabled: this._page.needsRequestInterception() }));
+    		
   }
 
   async _updateProtocolRequestInterception() {
@@ -156,7 +161,11 @@
     const enabled = this._protocolRequestInterceptionEnabled;
     if (initial && !enabled)
       return;
-    const cachePromise = info.session.send('Network.setCacheDisabled', { cacheDisabled: enabled });
+    
+    				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<any>(undefined);
     if (!info.workerFrame) {
       if (enabled)
@@ -238,6 +247,7 @@
   }
 
   _onRequestPaused(sessionInfo: SessionInfo, event: Protocol.Fetch.requestPausedPayload) {
+    if (this._alreadyTrackedNetworkIds.has(event.networkId)) return;
     if (!event.networkId) {
       // Fetch without networkId means that request was not recognized by inspector, and
       // it will never receive Network.requestWillBeSent. Continue the request to not affect it.
@@ -276,6 +286,10 @@
   }
 
   _onRequest(requestWillBeSentSessionInfo: SessionInfo, requestWillBeSentEvent: Protocol.Network.requestWillBeSentPayload, requestPausedSessionInfo: SessionInfo | undefined, requestPausedEvent: Protocol.Fetch.requestPausedPayload | undefined) {
+
+    			if (this._alreadyTrackedNetworkIds.has(requestWillBeSentEvent.requestId))
+    				return;
+    		
     if (requestWillBeSentEvent.request.url.startsWith('data:'))
       return;
     let redirectedFrom: InterceptableRequest | null = null;
@@ -287,6 +301,13 @@
         redirectedFrom = request;
       }
     }
+    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;
     // Requests from workers lack frameId, because we receive Network.requestWillBeSent
     // on the worker target. However, we receive Fetch.requestPaused on the page target,
@@ -306,7 +327,6 @@
     // we accept all CORS options, assuming that this was intended when setting route.
     //
     // Note: it would be better to match the URL against interception patterns.
-    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: Protocol.Fetch.HeaderEntry[] = [
@@ -346,7 +366,7 @@
         }
         requestPausedSessionInfo!.session._sendMayFail('Fetch.continueRequest', { requestId: requestPausedEvent.requestId, headers: headersOverride });
       } else {
-        route = new RouteImpl(requestPausedSessionInfo!.session, requestPausedEvent.requestId);
+        route = new RouteImpl(requestPausedSessionInfo!.session, requestPausedEvent.requestId, this._page, requestPausedEvent.networkId ?? requestPausedEvent.requestId, this);
       }
     }
     const isNavigationRequest = requestWillBeSentEvent.requestId === requestWillBeSentEvent.loaderId && requestWillBeSentEvent.type === 'Document';
@@ -558,6 +578,8 @@
     if (request.session !== sessionInfo.session && !sessionInfo.isMain && (request._documentId === request._requestId || sessionInfo.workerFrame))
       request.session = sessionInfo.session;
   }
+
+  _alreadyTrackedNetworkIds: Set<string> = new Set();
 }
 
 class InterceptableRequest {
@@ -614,38 +636,148 @@
   _alreadyContinuedParams: Protocol.Fetch.continueRequestParameters | undefined;
   _fulfilled: boolean = false;
 
-  constructor(session: CRSession, interceptionId: string) {
+  constructor(session: CRSession, interceptionId: string, page: Page | null, networkId: string, sessionManager: CRNetworkManager) {
+    this._page = void 0;
+    this._networkId = void 0;
+    this._sessionManager = void 0;
     this._session = session;
     this._interceptionId = interceptionId;
+    this._page = page;
+    this._networkId = networkId;
+    this._sessionManager = sessionManager;
+    eventsHelper.addEventListener(this._session, 'Fetch.requestPaused', async e => await this._networkRequestIntercepted(e));
   }
 
   async continue(overrides: types.NormalizedContinueOverrides): Promise<void> {
-    this._alreadyContinuedParams = {
-      requestId: this._interceptionId!,
-      url: overrides.url,
-      headers: overrides.headers,
-      method: overrides.method,
-      postData: overrides.postData ? overrides.postData.toString('base64') : undefined
-    };
-    await catchDisallowedErrors(async () => {
-      await this._session.send('Fetch.continueRequest', this._alreadyContinuedParams);
-    });
+    		;
+    		this._alreadyContinuedParams = {
+    			requestId: this._interceptionId,
+    			url: overrides.url,
+    			headers: overrides.headers,
+    			method: overrides.method,
+    			postData: overrides.postData?.toString('base64'),
+    		};
+    		if (overrides.url && (overrides.url === 'http://patchright-init-script-inject.internal/' || overrides.url === 'https://patchright-init-script-inject.internal/')) {
+    			await catchDisallowedErrors(async () => {
+    				this._sessionManager._alreadyTrackedNetworkIds.add(this._networkId);
+    				try {
+    					await this._session._sendMayFail('Fetch.continueRequest', { requestId: this._interceptionId, interceptResponse: true });
+    				} catch (e) {
+    					this._sessionManager._alreadyTrackedNetworkIds.delete(this._networkId);
+    					throw e;
+    				}
+    			});
+    		} else {
+    			await catchDisallowedErrors(async () => {
+    				await this._session._sendMayFail('Fetch.continueRequest', this._alreadyContinuedParams);
+    			});
+    		}
+    	
   }
 
   async fulfill(response: types.NormalizedFulfillResponse) {
-    this._fulfilled = true;
-    const body = response.isBase64 ? response.body : Buffer.from(response.body).toString('base64');
 
-    const responseHeaders = splitSetCookieHeader(response.headers);
-    await catchDisallowedErrors(async () => {
-      await this._session.send('Fetch.fulfillRequest', {
-        requestId: this._interceptionId!,
-        responseCode: response.status,
-        responsePhrase: network.statusText(response.status),
-        responseHeaders,
-        body,
-      });
-    });
+    		const isTextHtml = response.headers.some((header) => header.name.toLowerCase() === "content-type" && header.value.includes("text/html"));
+    		const pageDelegate = this._page?.delegate ?? null;
+    		const initScriptTag = pageDelegate?.initScriptTag ?? "";
+    		const allInjections = pageDelegate
+    			? [...pageDelegate._mainFrameSession._evaluateOnNewDocumentScripts]
+    			: [];
+
+    		if (isTextHtml && allInjections.length && initScriptTag) {
+    			// Decode body if needed
+    			if (response.isBase64) {
+    				response.isBase64 = false;
+    				response.body = Buffer.from(response.body, "base64").toString("utf-8");
+    			}
+
+    			// CSP Detection and Fixing
+    			const cspHeaderNames = ["content-security-policy", "content-security-policy-report-only"];
+    			const extractNonce = (cspValue) => {
+    				const match = cspValue.match(/script-src[^;]*'nonce-([^'"s;]+)'/i);
+    				return match?.[1] ?? null;
+    			};
+    		  let useNonce = false;
+    			let scriptNonce = null;
+
+    			// Fix CSP in headers
+    			for (const header of response.headers) {
+    				if (cspHeaderNames.includes(header.name.toLowerCase())) {
+    					const originalCsp = header.value ?? "";
+    					// Extract nonce if present
+    					const nonce = !useNonce && extractNonce(originalCsp);
+    					if (nonce) {
+    						scriptNonce = nonce;
+    						useNonce = true;
+    					}
+
+    					header.value = this._fixCSP(originalCsp, scriptNonce);
+    				}
+    			}
+
+    			// Fix CSP in meta tags
+    			if (typeof response.body === "string" && response.body.length) {
+    				response.body = response.body.replace(
+    					/<meta[^>]*http-equiv=(?:"|')?Content-Security-Policy(?:"|')?[^>]*>/gi,
+    					(match) => {
+    						const contentMatch = match.match(/content=(?:"|')([^"']*)(?:"|')/i);
+    						if (!contentMatch)
+    							return match;
+
+    						let originalCsp = contentMatch[1];
+    						// Decode HTML entities
+    						originalCsp = originalCsp
+    							.replace(/&amp;/g, '&')  // Must be first!
+    							.replace(/&lt;/g, '<')
+    							.replace(/&gt;/g, '>')
+    							.replace(/&quot;/g, '"')
+    							.replace(/&#x27;/g, "'")
+    							.replace(/&#x22;/g, '"')
+    							.replace(/&nbsp;/g, ' ')
+    							.replace(/&#(d+);/g, (match, dec) => String.fromCharCode(dec))
+    							.replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+
+    						// Extract nonce if present
+    						const nonce = !useNonce && extractNonce(originalCsp);
+    						if (nonce) {
+    							scriptNonce = nonce;
+    							useNonce = true;
+    						}
+
+    						const fixedCsp = this._fixCSP(originalCsp, scriptNonce);
+    						// Re-encode for HTML
+    						const encodedCsp = fixedCsp.replace(/'/g, '&#x27;').replace(/"/g, '&#x22;');
+    						return match.replace(contentMatch[1], encodedCsp);
+    					}
+    				);
+    			}
+
+    			// Build injection HTML - only use nonce if one was found in existing CSP
+    			const nonceAttr = useNonce ? `nonce="${scriptNonce}"` : '';
+    			let injectionHTML = "";
+    			allInjections.forEach((script) => {
+    				let scriptId = crypto.randomBytes(22).toString("hex");
+    				let scriptSource = script.source ?? script;
+    				injectionHTML += `<script class="${initScriptTag}" ${nonceAttr} id="${scriptId}" type="text/javascript">document.getElementById("${scriptId}")?.remove();${scriptSource}</script>`;
+    			});
+
+    			// Inject at END of <head>
+    			response.body = this._injectIntoHead(response.body, injectionHTML);
+    		}
+
+    		this._fulfilled = true;
+    		const body = response.isBase64 ? response.body : Buffer.from(response.body).toString("base64");
+    		const responseHeaders = splitSetCookieHeader(response.headers);
+    		await catchDisallowedErrors(async () => {
+    			await this._session.send("Fetch.fulfillRequest", {
+    				requestId: response.interceptionId ? response.interceptionId : this._interceptionId,
+    				responseCode: response.status,
+    				responsePhrase: network.statusText(response.status),
+    				responseHeaders,
+    				body
+    			});
+    		});
+    	
   }
 
   async abort(errorCode: string = 'failed') {
@@ -658,6 +790,211 @@
       });
     });
   }
+
+  _fixCSP(csp: string | null, scriptNonce: string | null) {
+
+    		if (!csp || typeof csp !== 'string')
+    			return csp;
+
+    		// Split by semicolons and clean up
+    		const directives = csp.split(';')
+    			.map(d => d.trim())
+    			.filter(Boolean);
+
+    		const fixedDirectives = [];
+    		let hasScriptSrc = false;
+
+    		const addIfMissing = (values: string[], ...items: string[]) => {
+    			for (const item of items)
+    				if (!values.includes(item))
+    					values.push(item);
+    		};
+
+
+    		for (let directive of directives) {
+    			// Improved directive parsing to handle more edge cases
+    			const directiveMatch = directive.match(/^([a-zA-Z-]+)\s+(.*)$/);
+    			if (!directiveMatch) {
+    				fixedDirectives.push(directive);
+    				continue;
+    			}
+
+    			const directiveName = directiveMatch[1].toLowerCase();
+    			const directiveValues = directiveMatch[2].split(/\s+/).filter(Boolean);
+
+    			switch (directiveName) {
+    				case 'script-src':
+    					hasScriptSrc = true;
+
+    					// Add nonce if we have one and it's not already present
+    					if (scriptNonce && !directiveValues.some(v => v.includes(`nonce-${scriptNonce}`)))
+    						directiveValues.push(`'nonce-${scriptNonce}'`);
+
+    					// Add 'unsafe-eval' if not present
+    					addIfMissing(directiveValues, "'unsafe-eval'");
+
+    					// Add unsafe-inline if not present and no nonce is being used
+    					if (!scriptNonce)
+    						addIfMissing(directiveValues, "'unsafe-inline'");
+
+    					// Add wildcard for external scripts if not already present
+    					if (!directiveValues.includes("*") && !directiveValues.includes("'self'") && !directiveValues.some(v => v.includes("https:")))
+    						directiveValues.push("*");
+
+    					fixedDirectives.push(`script-src ${directiveValues.join(' ')}`);
+    					break;
+
+    				case 'style-src':
+    					// Add 'unsafe-inline' for styles if not present
+    					addIfMissing(directiveValues, "'unsafe-inline'");
+    					fixedDirectives.push(`style-src ${directiveValues.join(' ')}`);
+    					break;
+
+    				case 'img-src':
+    				case 'font-src':
+    					// Allow data: URLs for images/fonts if not already allowed
+    					if (!directiveValues.includes('*'))
+    						addIfMissing(directiveValues, 'data:');
+    					fixedDirectives.push(`${directiveName} ${directiveValues.join(' ')}`);
+    					break;
+
+    				case 'connect-src':
+    					// Allow WebSocket connections if not already allowed
+    					if (!directiveValues.some(v => v.includes('ws:') || v.includes('wss:') || v === '*'))
+    						addIfMissing(directiveValues, 'ws:', 'wss:');
+    					fixedDirectives.push(`connect-src ${directiveValues.join(' ')}`);
+    					break;
+
+    				case 'frame-ancestors':
+    					// If completely blocked with 'none', allow 'self' at least
+    					let frameAncestorValues = directiveValues.includes("'none'") ? "'self'" : directiveValues.join(' ');
+    					fixedDirectives.push(`frame-ancestors ${frameAncestorValues}`);
+    					break;
+
+    				default:
+    					// Keep other directives as-is
+    					fixedDirectives.push(directive);
+    			}
+    		}
+
+    		// Add script-src if it doesn't exist (for our injected scripts)
+    		if (!hasScriptSrc) {
+    			fixedDirectives.push(
+    				scriptNonce
+    					? `script-src 'self' 'unsafe-eval' 'nonce-${scriptNonce}' *`
+    					: `script-src 'self' 'unsafe-eval' 'unsafe-inline' *`
+    			);
+    		}
+
+    		return fixedDirectives.join('; ');
+    	
+  }
+
+  _injectIntoHead(body: string, injectionHTML: string) {
+
+    		// Inject at END of <head>
+    		const lower = body.toLowerCase();
+    		const headStartIndex = lower.indexOf("<head");
+
+    		if (headStartIndex !== -1) {
+    			const headStartTagEndIndex = lower.indexOf(">", headStartIndex) + 1;
+    			const headEndTagIndex = lower.indexOf("</head>", headStartIndex);
+
+    			if (headEndTagIndex !== -1) {
+    				// Find the first <script> tag in <head>, skipping HTML comments
+    				const headContent = lower.slice(headStartTagEndIndex, headEndTagIndex);
+
+    				// Look for the first <script> tag in the head content but ignore comments
+    				let firstScriptIndex = -1;
+    				let searchPos = 0;
+
+    				while (searchPos < headContent.length) {
+    					const commentStart = headContent.indexOf("<!--", searchPos);
+    					const scriptStart = headContent.indexOf("<script", searchPos);
+
+    					// No more script tags, inject at the end of head content
+    					if (scriptStart === -1)
+    						break;
+
+    					if (commentStart !== -1 && commentStart < scriptStart) {
+    						const commentEnd = headContent.indexOf("-->", commentStart);
+    						if (commentEnd === -1)
+    							break;
+
+    						// Skip past the comment and keep searching
+    						searchPos = commentEnd + 3;
+    					} else {
+    					  // Found a script tag outside a comment
+    						firstScriptIndex = scriptStart;
+    						break;
+    					}
+    				}
+
+    				const insertAt =
+    					firstScriptIndex !== -1
+    						? headStartTagEndIndex + firstScriptIndex   // Before first <script>
+    						: headEndTagIndex;                   		 // Before </head>
+
+    				return body.slice(0, insertAt) + injectionHTML + body.slice(insertAt);
+    			}
+
+    			// No </head> found — inject right after the opening <head> tag
+    			return body.slice(0, headStartTagEndIndex) + injectionHTML + body.slice(headStartTagEndIndex);
+    		}
+
+    		// No <head> — try after <!DOCTYPE>
+    		const doctypeIndex = lower.indexOf("<!doctype");
+    		if (doctypeIndex === 0) {
+    			const doctypeEnd = body.indexOf(">", doctypeIndex) + 1;
+    			return body.slice(0, doctypeEnd) + injectionHTML + body.slice(doctypeEnd);
+    		}
+
+    		// Try after <html>
+    		const htmlTagIndex = lower.indexOf("<html");
+    		if (htmlTagIndex !== -1) {
+    			const htmlTagEnd = body.indexOf(">", htmlTagIndex) + 1;
+    			return body.slice(0, htmlTagEnd) +  `<head>${injectionHTML}</head>` + body.slice(htmlTagEnd);
+    		}
+
+    		// Last resort — prepend to body
+    		return injectionHTML + body;
+    	
+  }
+
+  async _networkRequestIntercepted(event: Protocol.Fetch.requestPausedPayload) {
+
+    		if (this._networkId != event.networkId || !this._sessionManager._alreadyTrackedNetworkIds.has(event.networkId))
+    			return;
+
+    		const trackedNetworkId = event.networkId;
+    		try {
+    			if (event.resourceType !== 'Document')
+    				return;
+
+    			if (event.responseStatusCode >= 301 && event.responseStatusCode <= 308  || (event.redirectedRequestId && !event.responseStatusCode)) {
+    				await this._session.send('Fetch.continueRequest', { requestId: event.requestId, interceptResponse: true });
+    			} else {
+    				const responseBody = await this._session.send('Fetch.getResponseBody', { requestId: event.requestId });
+    				await this.fulfill({
+    					headers: event.responseHeaders,
+    					isBase64: true,
+    					body: responseBody.body,
+    					status: event.responseStatusCode,
+    					interceptionId: event.requestId,
+    					resourceType: event.resourceType,
+    				});
+    			}
+    		} catch (error) {
+    			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 });
+    			}
+    		} finally {
+    			this._sessionManager._alreadyTrackedNetworkIds.delete(trackedNetworkId);
+    		}
+    	
+  }
 }
 
 // In certain cases, protocol will return error if the request was already canceled
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/chromium/crPage.ts patchright/packages/playwright-core/src/server/chromium/crPage.ts
---
+++
@@ -45,7 +45,7 @@
 import type { Progress } from '../progress';
 import type * as types from '../types';
 import type * as channels from '@protocol/channels';
-
+import crypto from "crypto";
 
 export type WindowBounds = { top?: number, left?: number, width?: number, height?: number };
 
@@ -96,7 +96,10 @@
     this.updateOffline();
     this.updateExtraHTTPHeaders();
     this.updateHttpCredentials();
-    this.updateRequestInterception();
+    
+    		this._networkManager.setRequestInterception(true);
+    		this.initScriptTag = crypto.randomBytes(20).toString('hex');
+    	
     this._mainFrameSession = new FrameSession(this, client, targetId, null);
     this._sessions.set(targetId, this._mainFrameSession);
     if (opener && !browserContext._options.noDefaultViewport) {
@@ -126,15 +129,15 @@
   }
 
   _sessionForFrame(frame: frames.Frame): FrameSession {
-    // Frame id equals target id.
-    while (!this._sessions.has(frame._id)) {
-      const parent = frame.parentFrame();
-      if (!parent)
-        throw new Error(`Frame has been detached.`);
-      frame = parent;
+      // Frame id equals target id.
+      while (!this._sessions.has(frame._id)) {
+        const parent = frame.parentFrame();
+        if (!parent)
+          throw new Error(`Frame was detached`);
+        frame = parent;
+      }
+      return this._sessions.get(frame._id)!;
     }
-    return this._sessions.get(frame._id)!;
-  }
 
   private _sessionForHandle(handle: dom.ElementHandle): FrameSession {
     const frame = handle._context.frame;
@@ -225,6 +228,7 @@
   }
 
   async addInitScript(initScript: InitScript, world: types.World = 'main'): Promise<void> {
+    this._page.initScripts.push(initScript);
     await this._forAllFrameSessions(frame => frame._evaluateOnNewDocument(initScript, world));
   }
 
@@ -364,6 +368,19 @@
   async setDockTile(image: Buffer): Promise<void> {
     await this._mainFrameSession._client.send('Browser.setDockTile', { image: image.toString('base64') });
   }
+
+  async exposeBinding(binding: PageBinding) {
+
+    		await this._forAllFrameSessions(frame => frame._initBinding(binding));
+    		await Promise.all(this._page.frames().map(frame => frame.evaluateExpression(binding.source).catch(e => {})));
+    	
+  }
+
+  async removeExposedBindings() {
+
+    		await this._forAllFrameSessions(frame => frame._removeExposedBindings());
+    	
+  }
 }
 
 class FrameSession {
@@ -438,6 +455,7 @@
   }
 
   async _initialize(hasUIWindow: boolean) {
+    const pageEnablePromise = this._client.send('Page.enable');
     if (!this._page.isStorageStatePage && hasUIWindow &&
       !this._crPage._browserContext._browser.isClank() &&
       !this._crPage._browserContext._options.noDefaultViewport) {
@@ -451,6 +469,11 @@
     let lifecycleEventsEnabled: Promise<any>;
     if (!this._isMainFrame())
       this._addRendererListeners();
+
+    		let bufferedDialogEvents: any[] | undefined = this._isMainFrame() ? [] : undefined;
+    		if (bufferedDialogEvents)
+    			this._eventListeners.push(eventsHelper.addEventListener(this._client, 'Page.javascriptDialogOpening', (event: any) => bufferedDialogEvents ? bufferedDialogEvents.push(event) : undefined));
+    	
     this._addBrowserListeners();
 
     // Buffer attachedToTarget events until we receive the frame tree.
@@ -460,11 +483,18 @@
     this._bufferedAttachedToTargetEvents = [];
 
     const promises: Promise<any>[] = [
-      this._client.send('Page.enable'),
+      pageEnablePromise,
       this._client.send('Page.getFrameTree').then(({ frameTree }) => {
         if (this._isMainFrame()) {
           this._handleFrameTree(frameTree);
           this._addRendererListeners();
+
+          			// Replay any dialog events that arrived before _addRendererListeners
+          			const pendingDialogEvents = bufferedDialogEvents || [];
+          			bufferedDialogEvents = undefined;
+          			for (const event of pendingDialogEvents)
+          				this._onDialog(event);
+          		
         }
 
         // Now that we have the frame tree, it is possible to insert oopif targets at the right place.
@@ -472,17 +502,6 @@
         this._bufferedAttachedToTargetEvents = undefined;
         for (const event of attachedToTargetEvents)
           this._onAttachedToTarget(event);
-
-        const localFrames = this._isMainFrame() ? this._page.frames() : [this._page.frameManager.frame(this._targetId)!];
-        for (const frame of localFrames) {
-          // Note: frames might be removed before we send these.
-          this._client._sendMayFail('Page.createIsolatedWorld', {
-            frameId: frame._id,
-            grantUniveralAccess: true,
-            worldName: this._crPage.utilityWorldName,
-          });
-        }
-
         const isInitialEmptyPage = this._isMainFrame() && this._page.mainFrame().url() === ':';
         if (isInitialEmptyPage) {
           // Ignore lifecycle events, worlds and bindings for the initial empty page. It is never the final page
@@ -492,13 +511,24 @@
             this._eventListeners.push(eventsHelper.addEventListener(this._client, 'Page.lifecycleEvent', event => this._onLifecycleEvent(event)));
           });
         } 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").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.source).catch(e => {});
+          				for (const source of this._crPage._page.initScripts)
+          					frame.evaluateExpression(source.source).catch(e => {});
+          			}
+          		
           this._firstNonInitialNavigationCommittedFulfill();
           this._eventListeners.push(eventsHelper.addEventListener(this._client, 'Page.lifecycleEvent', event => this._onLifecycleEvent(event)));
         }
       }),
       this._client.send('Log.enable', {}),
       lifecycleEventsEnabled = this._client.send('Page.setLifecycleEventsEnabled', { enabled: true }),
-      this._client.send('Runtime.enable', {}),
       this._client.send('Page.addScriptToEvaluateOnNewDocument', {
         source: '',
         worldName: this._crPage.utilityWorldName,
@@ -509,8 +539,10 @@
     if (!this._page.isStorageStatePage) {
       if (this._crPage._browserContext.needsPlaywrightBinding())
         promises.push(this.exposePlaywrightBinding());
-      if (this._isMainFrame())
-        promises.push(this._client.send('Emulation.setFocusEmulationEnabled', { enabled: true }));
+      
+      		if (this._isMainFrame() && !this._crPage._browserContext._options.focusControl)
+      			promises.push(this._client.send("Emulation.setFocusEmulationEnabled", { enabled: true }));
+      	
       const options = this._crPage._browserContext._options;
       if (options.bypassCSP)
         promises.push(this._client.send('Page.setBypassCSP', { enabled: true }));
@@ -533,12 +565,22 @@
       promises.push(this._updateGeolocation(true));
       promises.push(this._updateEmulateMedia());
       promises.push(this._updateFileChooserInterception(true));
-      for (const initScript of this._crPage._page.allInitScripts())
-        promises.push(this._evaluateOnNewDocument(initScript, 'main', true /* runImmediately */));
+      
+      					  for (const binding of this._crPage._page.allBindings()) promises.push(this._initBinding(binding));
+      					  for (const initScript of this._crPage._browserContext.initScripts) promises.push(this._evaluateOnNewDocument(initScript, 'main'));
+      					  for (const initScript of this._crPage._page.initScripts) promises.push(this._evaluateOnNewDocument(initScript, 'main'));
+      				
     }
-    promises.push(this._client.send('Runtime.runIfWaitingForDebugger'));
+    
+    			if (!(this._crPage._page._pageBindings.size || this._crPage._browserContext._pageBindings.size))
+    				promises.push(this._client.send('Runtime.runIfWaitingForDebugger'));
+    		
     promises.push(this._firstNonInitialNavigationCommittedPromise);
     await Promise.all(promises);
+
+    			if (this._crPage._page._pageBindings.size || this._crPage._browserContext._pageBindings.size)
+    				await this._client.send('Runtime.runIfWaitingForDebugger');
+    		
   }
 
   dispose() {
@@ -562,13 +604,33 @@
     return { newDocumentId: response.loaderId };
   }
 
-  _onLifecycleEvent(event: Protocol.Page.lifecycleEventPayload) {
+  async _onLifecycleEvent(event: Protocol.Page.lifecycleEventPayload) {
     if (this._eventBelongsToStaleFrame(event.frameId))
       return;
     if (event.name === 'load')
       this._page.frameManager.frameLifecycleEvent(event.frameId, 'load');
     else if (event.name === 'DOMContentLoaded')
       this._page.frameManager.frameLifecycleEvent(event.frameId, 'domcontentloaded');
+
+    		// Only do full init script cleanup on load to reduce CDP round-trip pressure.
+    		// Other lifecycle events just get a minimal runIfWaitingForDebugger call.
+    		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
+    		var query = await this._client._sendMayFail("DOM.querySelectorAll", {
+    		  nodeId: document.root.nodeId,
+    		  selector: "[class=" + this._crPage.initScriptTag + "]"
+    		});
+    		if (!query) return
+    		for (const nodeId of query.nodeIds) await this._client._sendMayFail("DOM.removeNode", { nodeId: nodeId });
+    		await this._client._sendMayFail('Runtime.runIfWaitingForDebugger');
+    		// ensuring execution context
+    		try { await this._page.frameManager.frame(this._targetId)._context("utility") } catch { };
+    	
   }
 
   _handleFrameTree(frameTree: Protocol.Page.FrameTree) {
@@ -615,12 +677,33 @@
     this._page.frameManager.frameAttached(frameId, parentFrameId);
   }
 
-  _onFrameNavigated(framePayload: Protocol.Page.Frame, initial: boolean) {
+  async _onFrameNavigated(framePayload: Protocol.Page.Frame, initial: boolean) {
     if (this._eventBelongsToStaleFrame(framePayload.id))
       return;
     this._page.frameManager.frameCommittedNewDocumentNavigation(framePayload.id, framePayload.url + (framePayload.urlFragment || ''), framePayload.name || '', framePayload.loaderId, initial);
     if (!initial)
       this._firstNonInitialNavigationCommittedFulfill();
+
+    		await this._client._sendMayFail('Runtime.runIfWaitingForDebugger');
+    		// patchright: For non-initial navigations, skip DOM cleanup since the document just changed
+    		// and init script tags haven't been re-added yet. The _onLifecycleEvent("load") handler
+    		// will perform cleanup after the page finishes loading.
+    		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", {
+    			nodeId: document.root.nodeId,
+    			selector: "[class=" + this._crPage.initScriptTag + "]"
+    		});
+    		if (!query) return
+    		for (const nodeId of query.nodeIds) await this._client._sendMayFail("DOM.removeNode", { nodeId: nodeId });
+    		await this._client._sendMayFail('Runtime.runIfWaitingForDebugger');
+    		// ensuring execution context
+    		try { await this._page.frameManager.frame(this._targetId)._context("utility") } catch { };
+    	
   }
 
   _onFrameRequestedNavigation(payload: Protocol.Page.frameRequestedNavigationPayload) {
@@ -657,19 +740,33 @@
   }
 
   _onExecutionContextCreated(contextPayload: Protocol.Runtime.ExecutionContextDescription) {
+
+    		for (const name of this._exposedBindingNames)
+    			this._client._sendMayFail('Runtime.addBinding', { name: name, executionContextId: contextPayload.id });
+    	
     const frame = contextPayload.auxData ? this._page.frameManager.frame(contextPayload.auxData.frameId) : null;
+
+    		if (contextPayload.auxData?.type === "worker") throw new Error("ExecutionContext is worker");
+    	
     if (!frame || this._eventBelongsToStaleFrame(frame._id))
       return;
     const delegate = new CRExecutionContext(this._client, contextPayload);
-    let worldName: types.World|null = null;
-    if (contextPayload.auxData && !!contextPayload.auxData.isDefault)
-      worldName = 'main';
-    else if (contextPayload.name === this._crPage.utilityWorldName)
-      worldName = 'utility';
+    let worldName = contextPayload.name;
     const context = new dom.FrameExecutionContext(delegate, frame, worldName);
-    if (worldName)
-      frame._contextCreated(worldName, context);
+    
+    		if (worldName && (worldName === 'main' || worldName === 'utility'))
+    			frame._contextCreated(worldName, context);
+    	
     this._contextIdToContext.set(contextPayload.id, context);
+
+    		for (const source of this._exposedBindingScripts) {
+    			this._client._sendMayFail("Runtime.evaluate", {
+    				expression: source,
+    				contextId: contextPayload.id,
+    				awaitPromise: true,
+    			})
+    		}
+    	
   }
 
   _onExecutionContextDestroyed(executionContextId: number) {
@@ -685,7 +782,7 @@
       this._onExecutionContextDestroyed(contextId);
   }
 
-  _onAttachedToTarget(event: Protocol.Target.attachedToTargetPayload) {
+  async _onAttachedToTarget(event: Protocol.Target.attachedToTargetPayload) {
     if (this._bufferedAttachedToTargetEvents) {
       this._bufferedAttachedToTargetEvents.push(event);
       return;
@@ -727,12 +824,22 @@
     session.once('Runtime.executionContextCreated', async event => {
       worker.createExecutionContext(new CRExecutionContext(session, event.context));
     });
+
+    			var globalThis = await session._sendMayFail('Runtime.evaluate', {
+    				expression: "globalThis",
+    				serializationOptions: { serialization: "idOnly" }
+    			});
+    			if (globalThis && globalThis.result) {
+    				var globalThisObjId = globalThis.result.objectId;
+    				var executionContextId = parseInt(globalThisObjId.split('.')[1], 10);
+    				worker.createExecutionContext(new CRExecutionContext(session, { id: executionContextId }));
+    			}
+    		
     if (this._crPage._browserContext._browser.majorVersion() >= 143)
       session.on('Inspector.workerScriptLoaded', () => worker.workerScriptLoaded());
     else
       worker.workerScriptLoaded();
     // This might fail if the target is closed before we initialize.
-    session._sendMayFail('Runtime.enable');
     // TODO: attribute workers to the right frame.
     this._crPage._networkManager.addSession(session, this._page.frameManager.frame(this._targetId) ?? undefined).catch(() => {});
     session._sendMayFail('Runtime.runIfWaitingForDebugger');
@@ -811,8 +918,10 @@
     const pageOrError = await this._crPage._page.waitForInitializedOrError();
     if (!(pageOrError instanceof Error)) {
       const context = this._contextIdToContext.get(event.executionContextId);
-      if (context)
-        await this._page.onBindingCalled(event.payload, context);
+      
+      		if (context) await this._page.onBindingCalled(event.payload, context);
+      		else await this._page._onBindingCalled(event.payload, (await this._page.mainFrame()._mainContext())) // This might be a bit sketchy but it works for now
+      	
     }
   }
 
@@ -1008,20 +1117,14 @@
   }
 
   async _evaluateOnNewDocument(initScript: InitScript, world: types.World, runImmediately?: boolean): Promise<void> {
-    const worldName = world === 'utility' ? this._crPage.utilityWorldName : undefined;
-    const { identifier } = await this._client.send('Page.addScriptToEvaluateOnNewDocument', { source: initScript.source, worldName, runImmediately });
-    this._initScriptIds.set(initScript, identifier);
+    this._evaluateOnNewDocumentScripts.push(initScript);		
   }
 
   async _removeEvaluatesOnNewDocument(initScripts: InitScript[]): Promise<void> {
-    const ids: string[] = [];
-    for (const script of initScripts) {
-      const id = this._initScriptIds.get(script);
-      if (id)
-        ids.push(id);
-      this._initScriptIds.delete(script);
-    }
-    await Promise.all(ids.map(identifier => this._client.send('Page.removeScriptToEvaluateOnNewDocument', { identifier }).catch(() => {}))); // target can be closed
+
+    			const toRemove = new Set(initScripts);
+    			this._evaluateOnNewDocumentScripts = this._evaluateOnNewDocumentScripts.filter(script => !toRemove.has(script));
+    		
   }
 
   async exposePlaywrightBinding() {
@@ -1126,12 +1229,53 @@
   async _adoptBackendNodeId(backendNodeId: Protocol.DOM.BackendNodeId, to: dom.FrameExecutionContext): Promise<dom.ElementHandle> {
     const result = await this._client._sendMayFail('DOM.resolveNode', {
       backendNodeId,
-      executionContextId: (to.delegate as CRExecutionContext)._contextId,
+      executionContextId: to.delegate._contextId,
     });
     if (!result || result.object.subtype === 'null')
       throw new Error(dom.kUnableToAdoptErrorMessage);
     return createHandle(to, result.object).asElement()!;
   }
+
+  _exposedBindingNames: string[] = [];
+  _evaluateOnNewDocumentScripts: InitScript[] = [];
+  _parsedExecutionContextIds: number[] = [];
+  _exposedBindingScripts: string[] = [];
+
+  async _initBinding(binding = PageBinding) {
+
+    		// Remember this binding so future execution contexts get it in _onExecutionContextCreated.
+    		this._exposedBindingNames.push(binding.name);
+    		this._exposedBindingScripts.push(binding.source);
+
+    		// Install binding in all existing execution contexts.
+    		const contextIds = Array.from(this._contextIdToContext.keys());
+    		await Promise.all([
+    			this._client._sendMayFail('Runtime.addBinding', { name: binding.name }),
+    			...contextIds.map(executionContextId => this._client._sendMayFail('Runtime.addBinding', { name: binding.name, executionContextId })),
+    		]);
+
+    		// Evaluate binding bootstrap in all existing execution contexts.
+    		const evaluationPromises = contextIds.map(contextId =>
+    			this._client._sendMayFail('Runtime.evaluate', {
+    				expression: binding.source,
+    				contextId,
+    				awaitPromise: true,
+    			}).catch(e => { }),
+    		);
+    		await Promise.all(evaluationPromises);
+    	
+  }
+
+  async _removeExposedBindings() {
+
+    		const toRetain: string[] = [];
+    		const toRemove: string[] = [];
+    		for (const name of this._exposedBindingNames)
+    			(name.startsWith('__pw_') ? toRetain : toRemove).push(name);
+    		this._exposedBindingNames = toRetain;
+    		await Promise.all(toRemove.map(name => this._client.send('Runtime.removeBinding', { name })));
+    	
+  }
 }
 
 async function emulateLocale(session: CRSession, locale: string) {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/chromium/crServiceWorker.ts patchright/packages/playwright-core/src/server/chromium/crServiceWorker.ts
---
+++
@@ -63,13 +63,23 @@
       const message = new ConsoleMessage(null, this, event.type, undefined, args, toConsoleMessageLocation(event.stackTrace), event.timestamp);
       this.browserContext.emit(BrowserContext.Events.Console, message);
     });
-
-    session.send('Runtime.enable', {}).catch(e => {});
     session.send('Runtime.runIfWaitingForDebugger').catch(e => {});
     session.on('Inspector.targetReloadedAfterCrash', () => {
       // Resume service worker after restart.
       session._sendMayFail('Runtime.runIfWaitingForDebugger', {});
     });
+
+    		session._sendMayFail("Runtime.evaluate", {
+    			expression: "globalThis",
+    			serializationOptions: { serialization: "idOnly" }
+    		}).then(globalThis => {
+    			if (globalThis && globalThis.result) {
+    				var globalThisObjId = globalThis.result.objectId;
+    				var executionContextId = parseInt(globalThisObjId.split(".")[1], 10);
+    				this.createExecutionContext(new CRExecutionContext(session, { id: executionContextId }));
+    			}
+    		});
+    	
   }
 
   override didClose() {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/clock.ts patchright/packages/playwright-core/src/server/clock.ts
---
+++
@@ -106,6 +106,15 @@
   }
 
   private async _evaluateInFrames(script: string) {
+
+    			// Dont ask me why this works
+    			const frames = this._browserContext.pages().flatMap((page) => page.frames());
+    			await Promise.all(frames.map(async (frame) => {
+    				try {
+    					await frame.evaluateExpression("");
+    				} catch {}
+    			}));
+    		
     await this._browserContext.safeNonStallingEvaluateInAllFrames(script, 'main', { throwOnJSErrors: true });
   }
 }
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts patchright/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
---
+++
@@ -124,12 +124,12 @@
         });
       }
     });
-    this._dialogHandler = dialog => {
-      if (!this._shouldDispatchEvent(dialog.page(), 'dialog'))
-        return false;
-      this._dispatchEvent('dialog', { dialog: new DialogDispatcher(this, dialog) });
-      return true;
-    };
+    
+    		this._dialogHandler = dialog => {
+    			this._dispatchEvent('dialog', { dialog: new DialogDispatcher(this, dialog) });
+    			return true;
+    		};
+    	
     context.dialogManager.addDialogHandler(this._dialogHandler);
 
     if (context._browser.options.name === 'chromium' && this._object._browser instanceof CRBrowser) {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts patchright/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts
---
+++
@@ -84,11 +84,36 @@
   }
 
   async evaluateExpression(params: channels.FrameEvaluateExpressionParams, progress: Progress): Promise<channels.FrameEvaluateExpressionResult> {
-    return { value: serializeResult(await progress.race(this._frame.evaluateExpression(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)))) };
+
+    		return {
+    			value: serializeResult(
+    				await progress.race(
+    					this._frame.evaluateExpression(
+    						params.expression,
+    						{ isFunction: params.isFunction, world: params.isolatedContext ? 'utility': 'main' },
+    						parseArgument(params.arg)
+    					)
+    				)
+    			)
+    		};
+    	
   }
 
   async evaluateExpressionHandle(params: channels.FrameEvaluateExpressionHandleParams, progress: Progress): Promise<channels.FrameEvaluateExpressionHandleResult> {
-    return { handle: ElementHandleDispatcher.fromJSOrElementHandle(this, await progress.race(this._frame.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)))) };
+
+    		return {
+    			handle: ElementHandleDispatcher.fromJSOrElementHandle(
+    				this,
+    				await progress.race(
+    					this._frame.evaluateExpressionHandle(
+    						params.expression,
+    						{ isFunction: params.isFunction, world: params.isolatedContext ? 'utility': 'main' },
+    						parseArgument(params.arg)
+    					)
+    				)
+    			)
+    		};
+    	
   }
 
   async waitForSelector(params: channels.FrameWaitForSelectorParams, progress: Progress): Promise<channels.FrameWaitForSelectorResult> {
@@ -104,7 +129,20 @@
   }
 
   async evalOnSelectorAll(params: channels.FrameEvalOnSelectorAllParams, progress: Progress): Promise<channels.FrameEvalOnSelectorAllResult> {
-    return { value: serializeResult(await progress.race(this._frame.evalOnSelectorAll(params.selector, params.expression, params.isFunction, parseArgument(params.arg)))) };
+
+    		return {
+    			value: serializeResult(
+    				await this._frame.evalOnSelectorAll(
+    					params.selector,
+    					params.expression,
+    					params.isFunction,
+    					parseArgument(params.arg),
+    					null,
+    					params.isolatedContext
+    				)
+    			)
+    		};
+    	
   }
 
   async querySelector(params: channels.FrameQuerySelectorParams, progress: Progress): Promise<channels.FrameQuerySelectorResult> {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/dispatchers/jsHandleDispatcher.ts patchright/packages/playwright-core/src/server/dispatchers/jsHandleDispatcher.ts
---
+++
@@ -43,12 +43,12 @@
   }
 
   async evaluateExpression(params: channels.JSHandleEvaluateExpressionParams, progress: Progress): Promise<channels.JSHandleEvaluateExpressionResult> {
-    const jsHandle = await progress.race(this._object.evaluateExpression(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)));
+    const jsHandle = await progress.race(this._object.evaluateExpression(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg), params.isolatedContext));
     return { value: serializeResult(jsHandle) };
   }
 
   async evaluateExpressionHandle(params: channels.JSHandleEvaluateExpressionHandleParams, progress: Progress): Promise<channels.JSHandleEvaluateExpressionHandleResult> {
-    const jsHandle = await progress.race(this._object.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)));
+    const jsHandle = await progress.race(this._object.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg), params.isolatedContext));
     // If "jsHandle" is an ElementHandle, it belongs to the same frame as "this".
     return { handle: ElementHandleDispatcher.fromJSOrElementHandle(this.parentScope() as FrameDispatcher, jsHandle) };
   }
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/frameSelectors.ts patchright/packages/playwright-core/src/server/frameSelectors.ts
---
+++
@@ -23,7 +23,10 @@
 import type { JSHandle } from './javascript';
 import type * as types from './types';
 import type { ParsedSelector } from '../utils/isomorphic/selectorParser';
-
+import { ElementHandle } from "./dom";
+import type { CRSession } from "./chromium/crConnection";
+import type { Progress } from "./progress";
+import type { Protocol } from "./chromium/protocol";
 
 export type SelectorInfo = {
   parsed: ParsedSelector,
@@ -65,8 +68,8 @@
     return adoptIfNeeded(elementHandle, await resolved.frame._mainContext());
   }
 
-  async queryArrayInMainWorld(selector: string, scope?: ElementHandle): Promise<JSHandle<Element[]>> {
-    const resolved = await this.resolveInjectedForSelector(selector, { mainWorld: true }, scope);
+  async queryArrayInMainWorld(selector: string, scope?: ElementHandle, isolatedContext?: boolean): Promise<JSHandle<Element[]>> {
+    const resolved = await this.resolveInjectedForSelector(selector, { mainWorld: !isolatedContext }, scope);
     // Be careful, |this.frame| can be different from |resolved.frame|.
     if (!resolved)
       throw new Error(`Failed to find frame for selector "${selector}"`);
@@ -156,9 +159,26 @@
           throw injected.createStacklessError(`Selector "${selectorString}" resolved to ${injected.previewNode(element)}, <iframe> was expected`);
         return element;
       }, { info, scope: i === 0 ? scope : undefined, selectorString: stringifySelector(info.parsed) });
-      const element = handle.asElement() as ElementHandle<Element> | null;
-      if (!element)
-        return null;
+      let element = handle.asElement() as ElementHandle<Element> | null;
+      
+      		if (!element) {
+      			try {
+      				var client = frame._page.delegate._sessionForFrame(frame)._client;
+      			} catch (e) {
+      				var client = frame._page.delegate._mainFrameSession._client;
+      			}
+      			var mainContext = await frame._context("main");
+      			const documentNode = await client.send("Runtime.evaluate", {
+      				expression: "document",
+      				serializationOptions: { serialization: "idOnly" },
+      				contextId: mainContext.delegate._contextId
+      			});
+      			const documentScope = new ElementHandle(mainContext, documentNode.result.objectId);
+      				var check = await this._customFindFramesByParsed(injectedScript, client, mainContext, documentScope, undefined, info.parsed);
+      			if (check.length === 0) return null;
+      			element = check[0];
+      		}
+      	
       const maybeFrame = await frame._page.delegate.getContentFrame(element);
       element.dispose();
       if (!maybeFrame)
@@ -179,9 +199,194 @@
     if (!resolved)
       return;
     const context = await resolved.frame._context(options?.mainWorld ? 'main' : resolved.info.world);
+    if (!context) throw new Error("Frame was detached");
     const injected = await context.injectedScript();
     return { injected, info: resolved.info, frame: resolved.frame, scope: resolved.scope };
   }
+
+  async _customFindFramesByParsed(resolved: JSHandle<InjectedScript>, client: CRSession, context: FrameExecutionContext, documentScope: ElementHandle, progress: Progress | undefined, parsed: ParsedSelector) {
+
+    		var parsedEdits = { ...parsed };
+    		const callId = progress?.metadata.id;
+    		// Note: We start scoping at document level
+    		var currentScopingElements = [documentScope];
+
+    		for (const part of [...parsed.parts]) {
+    			parsedEdits.parts = [part];
+    			var elements = [];
+
+    			if (part.name === "nth") {
+    				const partNth = Number(part.body);
+    				// Check if any Elements are currently scoped, else return empty array to continue polling
+    				if (currentScopingElements.length == 0)
+    					return [];
+
+    				if (partNth > currentScopingElements.length-1 || partNth < -(currentScopingElements.length-1)) {
+    					if (parsed.capture !== undefined)
+    						throw new Error("Can't query n-th element in a request with the capture.");
+    					return [];
+    				}
+    				currentScopingElements = [currentScopingElements.at(partNth)];
+    				continue;
+    			} else if (part.name === "internal:or") {
+    				var orredElements = await this._customFindFramesByParsed(resolved, client, context, documentScope, progress, part.body.parsed);
+    				elements = [...currentScopingElements, ...orredElements];
+    			} else if (part.name == "internal:and") {
+    				var andedElements = await this._customFindFramesByParsed(resolved, client, context, documentScope, progress, part.body.parsed);
+    				const backendNodeIds = new Set(andedElements.map(elem => elem.backendNodeId));
+    				elements = currentScopingElements.filter(elem => backendNodeIds.has(elem.backendNodeId));
+    			} else {
+    				for (const scope of currentScopingElements) {
+    					const describedScope = await client.send("DOM.describeNode", {
+    						objectId: scope._objectId,
+    						depth: -1,
+    						pierce: true
+    					});
+
+    					let findClosedShadowRoots = function(node, results = []) {
+    						if (!node || typeof node !== "object") return results;
+    						if (node.shadowRoots && Array.isArray(node.shadowRoots)) {
+    							for (const shadowRoot of node.shadowRoots) {
+    								if (shadowRoot.shadowRootType === "closed" && shadowRoot.backendNodeId) {
+    									results.push(shadowRoot.backendNodeId);
+    								}
+    								findClosedShadowRoots(shadowRoot, results);
+    							}
+    						}
+    						if (node.nodeName !== "IFRAME" && node.children && Array.isArray(node.children)) {
+    							for (const child of node.children) {
+    								findClosedShadowRoots(child, results);
+    							}
+    						}
+    						return results;
+    					};
+    					var shadowRootBackendIds = findClosedShadowRoots(describedScope.node);
+
+    					const shadowRoots = await Promise.all(
+    						shadowRootBackendIds.map(async backendNodeId => {
+    							const resolved = await client.send("DOM.resolveNode", {
+    								backendNodeId,
+    								contextId: context.delegate._contextId,
+    							});
+    							return new ElementHandle(context, resolved.object.objectId);
+    						})
+    					);
+
+    					// Elements Queryed in the "current round"
+    					const queryGroups: { handles: any; parentNode: any }[] = [];
+    					for (var shadowRoot of shadowRoots) {
+    						const shadowHandles = await shadowRoot.evaluateHandleInUtility(
+    							([injected, node, { parsed, callId }]) => {
+    							 	const elements = injected.querySelectorAll(parsed, node);
+    								if (callId)
+    									injected.markTargetElements(new Set(elements), callId);
+    								return elements;
+    							}, {
+    								parsed: parsedEdits,
+    								callId
+    							}
+    						);
+    						queryGroups.push({ handles: shadowHandles, parentNode: shadowRoot });
+    					}
+
+    					// Document Root Elements (not in CSR)
+    					const rootHandles = await scope.evaluateHandleInUtility(
+    						([injected, node, { parsed, callId }]) => {
+    						 	const elements = injected.querySelectorAll(parsed, node);
+    							if (callId)
+    								injected.markTargetElements(new Set(elements), callId);
+    							return elements;
+    						}, {
+    							parsed: parsedEdits,
+    							callId
+    						}
+    					);
+    					queryGroups.push({ handles: rootHandles, parentNode: scope });
+
+    					// Querying and Sorting the elements by their backendNodeId
+    					for (const { handles, parentNode } of queryGroups) {
+    						const handlesAmount = await (await handles.getProperty("length")).jsonValue();
+    						for (var i = 0; i < handlesAmount; i++) {
+    						  if (parentNode instanceof ElementHandle) {
+    								var element = await parentNode.evaluateHandleInUtility(
+    									([injected, node, { i, handles: elems }]) => elems[i],
+    									{ i, handles }
+    								);
+    							} else {
+    								var element = await parentNode.evaluateHandle(
+    									(injected, { i, handles: elems }) => elems[i],
+    									{ i, handles }
+    								);
+    							}
+
+    							// For other Functions/Utilities
+    							element.parentNode = parentNode;
+    							const resolvedElement = await client.send("DOM.describeNode", { objectId: element._objectId, depth: -1 });
+    							element.backendNodeId = resolvedElement.node.backendNodeId;
+    							element.nodePosition = await this._findElementPositionInDomTree(element, describedScope.node, context, "");
+    							elements.push(element);
+    						}
+    					}
+    				}
+    			}
+
+    			// Sorting elements by their nodePosition, which is a index to the Element in the DOM tree
+    			const getParts = (pos) => (pos || '').split('.').filter(Boolean).map(Number);
+    			elements.sort((a, b) => {
+    				const partsA = getParts(a.nodePosition);
+    				const partsB = getParts(b.nodePosition);
+
+    				for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    					const diff = (partsA[i] ?? -1) - (partsB[i] ?? -1);
+    					if (diff !== 0) return diff;
+    				}
+    				return 0;
+    			});
+
+    			// Remove duplicates by backendNodeId, keeping the first occurrence
+    			currentScopingElements = Array.from(
+    				new Map(elements.map(e => [e.backendNodeId, e])).values()
+    			);
+    		}
+
+    		return currentScopingElements;
+    	
+  }
+
+  async _findElementPositionInDomTree(element: { backendNodeId: number }, queryingElement: Protocol.DOM.Node, context: FrameExecutionContext, currentIndex: string) {
+
+    		// Get Element Position in DOM Tree by Indexing it via their children indexes, like a search tree index
+    		// Check if backendNodeId matches, if so, return currentIndex
+    		if (element.backendNodeId === queryingElement.backendNodeId)
+    			return currentIndex;
+
+    		// Iterating through children of queryingElement
+    		for (const [childrenNodeIndex, child] of (queryingElement.children || []).entries()) {
+    			// Further querying the child recursively and appending the children index to the currentIndex
+    			const childIndex = await this._findElementPositionInDomTree(element, child, context, currentIndex + "." + childrenNodeIndex.toString());
+    			if (childIndex !== null) return childIndex;
+    		}
+
+    		for (const shadowRoot of queryingElement.shadowRoots || []) {
+    			// For CSRs, we dont have to append its index because patchright treats CSRs like they dont exist
+    			if (shadowRoot.shadowRootType === "closed" && shadowRoot.backendNodeId) {
+    				// Resolve the CDP client for the current context so closed shadow roots can be traversed safely.
+    				const client = context.frame._page.delegate._sessionForFrame(context.frame)._client;
+    				const describedShadowRoot = await client.send("DOM.describeNode", { backendNodeId: shadowRoot.backendNodeId, depth: -1, pierce: true });
+    				if (describedShadowRoot && describedShadowRoot.node) {
+    					const childIndex = await this._findElementPositionInDomTree(element, describedShadowRoot.node, context, currentIndex);
+    					if (childIndex !== null) return childIndex;
+    				}
+    			}
+    			// Traverse into shadow root children (open and closed) to properly position elements inside shadow DOMs
+    			for (const [shadowChildIndex, shadowChild] of (shadowRoot.children || []).entries()) {
+    				const childIndex = await this._findElementPositionInDomTree(element, shadowChild, context, currentIndex + "." + shadowChildIndex.toString());
+    				if (childIndex !== null) return childIndex;
+    			}
+    		}
+    		return null;
+    	
+  }
 }
 
 async function adoptIfNeeded<T extends Node>(handle: ElementHandle<T>, context: FrameExecutionContext): Promise<ElementHandle<T>> {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/frames.ts patchright/packages/playwright-core/src/server/frames.ts
---
+++
@@ -42,6 +42,10 @@
 import type { RegisteredListener } from './utils/eventsHelper';
 import type { ParsedSelector } from '../utils/isomorphic/selectorParser';
 import type * as channels from '@protocol/channels';
+import { CRExecutionContext } from "./chromium/crExecutionContext";
+import { FrameExecutionContext } from "./dom";
+import type { CRSession } from "./chromium/crConnection";
+import crypto from "crypto";
 
 type ContextData = {
   contextPromise: ManualPromise<dom.FrameExecutionContext | { destroyedReason: string }>;
@@ -239,6 +243,9 @@
       // No pending - just commit a new document.
       frame._currentDocument = { documentId, request: undefined };
     }
+    frame._iframeWorld = undefined;
+    frame._mainWorld = undefined;
+    frame._isolatedWorld = undefined;
 
     frame._onClearLifecycle();
     const navigationEvent: NavigationEvent = { url, name, newDocument: frame._currentDocument, isPublic: true };
@@ -572,12 +579,15 @@
   }
 
   nonStallingEvaluateInExistingContext(expression: string, world: types.World): Promise<any> {
-    return this.raceAgainstEvaluationStallingEvents(() => {
-      const context = this._contextData.get(world)?.context;
-      if (!context)
-        throw new Error('Frame does not yet have the execution context');
-      return context.evaluateExpression(expression, { isFunction: false });
-    });
+
+    		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');
+    			return context.evaluateExpression(expression, { isFunction: false });
+    		});
+    	
   }
 
   _recalculateNetworkIdle(frameThatAllowsRemovingNetworkIdle?: Frame) {
@@ -722,12 +732,69 @@
     return this._page.delegate.getFrameElement(this);
   }
 
-  _context(world: types.World): Promise<dom.FrameExecutionContext> {
-    return this._contextData.get(world)!.contextPromise.then(contextOrDestroyedReason => {
-      if (contextOrDestroyedReason instanceof js.ExecutionContext)
-        return contextOrDestroyedReason;
-      throw new Error(contextOrDestroyedReason.destroyedReason);
-    });
+  async _context(world: types.World): Promise<dom.FrameExecutionContext> {
+
+    		if (this.isDetached())
+    			throw new Error('Frame was detached');
+
+    		let client;
+    		try {
+    			client = this._page.delegate._sessionForFrame(this)._client;
+    		} catch (e) {
+    			client = this._page.delegate._mainFrameSession._client;
+    		}
+
+    		var iframeExecutionContextId = await this._getFrameMainFrameContextId(client);
+    		const isMainFrame = this === this._page.mainFrame();
+    		const session = this._page.delegate._sessionForFrame(this);
+
+    		const registerContext = (executionContextId: number, worldName: string) => {
+    			const crContext = new CRExecutionContext(client, { id: executionContextId }, this._id);
+    			const frameContext = new FrameExecutionContext(crContext, this, worldName);
+    			session._onExecutionContextCreated({
+    				id: executionContextId,
+    				origin: worldName,
+    				name: worldName,
+    				auxData: { isDefault: isMainFrame, type: 'isolated', frameId: this._id },
+    			});
+    			return frameContext;
+    		};
+
+    		if (world === "main") {
+    			// Iframe Only
+    			if (!isMainFrame && iframeExecutionContextId && this._iframeWorld === undefined) {
+    				this._iframeWorld = registerContext(iframeExecutionContextId, world);
+    			} else if (this._mainWorld === undefined) {
+    				const globalThis = await client._sendMayFail('Runtime.evaluate', {
+    					expression: "globalThis",
+    					serializationOptions: { serialization: "idOnly" },
+    				});
+    				if (!globalThis) {
+    					if (this.isDetached()) throw new Error('Frame was detached');
+    					return;
+    				}
+    				const executionContextId = parseInt(globalThis.result.objectId.split('.')[1], 10);
+    				this._mainWorld = registerContext(executionContextId, world);
+    			}
+    		}
+
+    		if (world !== "main" && this._isolatedWorld === undefined) {
+    			const result = await client._sendMayFail('Page.createIsolatedWorld', {
+    				frameId: this._id, grantUniveralAccess: true, worldName: world,
+    			});
+    			if (!result) {
+    				if (this.isDetached()) throw new Error("Frame was detached");
+    				return;
+    			}
+    			this._isolatedWorld = registerContext(result.executionContextId, "utility");
+    		}
+
+    		if (world !== "main")
+    			return this._isolatedWorld;
+    		if (!isMainFrame && this._iframeWorld)
+    			return this._iframeWorld;
+    		return this._mainWorld;
+    	
   }
 
   _mainContext(): Promise<dom.FrameExecutionContext> {
@@ -743,107 +810,168 @@
   }
 
   async evaluateExpression(expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<any> {
-    const context = await this._context(options.world ?? 'main');
-    const value = await context.evaluateExpression(expression, options, arg);
-    return value;
+
+    		const context = await this._detachedScope.race(this._context(options.world ?? "main"));
+    		return await this._detachedScope.race(context.evaluateExpression(expression, options, arg));
+    	
   }
 
   async evaluateExpressionHandle(expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<js.JSHandle<any>> {
-    const context = await this._context(options.world ?? 'main');
-    const value = await context.evaluateExpressionHandle(expression, options, arg);
-    return value;
+
+    		const context = await this._detachedScope.race(this._context(options.world ?? "utility"));
+    		return await this._detachedScope.race(context.evaluateExpressionHandle(expression, options, arg));
+    	
   }
 
   async querySelector(selector: string, options: types.StrictOptions): Promise<dom.ElementHandle<Element> | null> {
-    this.apiLog(`    finding element using the selector "${selector}"`);
-    return this.selectors.query(selector, options);
+
+    		return this.querySelectorAll(selector, options).then((handles) => {
+    			if (handles.length === 0)
+    				return null;
+    			if (handles.length > 1 && options?.strict)
+    				throw new Error(`Strict mode: expected one element matching selector "${selector}", found ${handles.length}`);
+    			return handles[0];
+    		});
+    	
   }
 
   async waitForSelector(progress: Progress, selector: string, performActionPreChecksAndLog: boolean, options: types.WaitForElementOptions, scope?: dom.ElementHandle): Promise<dom.ElementHandle<Element> | null> {
-    if ((options as any).visibility)
-      throw new Error('options.visibility is not supported, did you mean options.state?');
-    if ((options as any).waitFor && (options as any).waitFor !== 'visible')
-      throw new Error('options.waitFor is not supported, did you mean options.state?');
-    const { state = 'visible' } = options;
-    if (!['attached', 'detached', 'visible', 'hidden'].includes(state))
-      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.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-      if (performActionPreChecksAndLog)
-        await this._page.performActionPreChecks(progress);
 
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
-      if (!resolved) {
-        if (state === 'hidden' || state === 'detached')
-          return null;
-        return continuePolling;
-      }
-      const result = await progress.race(resolved.injected.evaluateHandle((injected, { info, root }) => {
-        if (root && !root.isConnected)
-          throw injected.createStacklessError('Element is not attached to the DOM');
-        const elements = injected.querySelectorAll(info.parsed, root || document);
-        const element: Element | undefined  = elements[0];
-        const visible = element ? injected.utils.isElementVisible(element) : false;
-        let log = '';
-        if (elements.length > 1) {
-          if (info.strict)
-            throw injected.strictModeViolationError(info.parsed, elements);
-          log = `  locator resolved to ${elements.length} elements. Proceeding with the first one: ${injected.previewNode(elements[0])}`;
-        } else if (element) {
-          log = `  locator resolved to ${visible ? 'visible' : 'hidden'} ${injected.previewNode(element)}`;
-        }
-        injected.checkDeprecatedSelectorUsage(info.parsed, elements);
-        return { log, element, visible, attached: !!element };
-      }, { info: resolved.info, root: resolved.frame === this ? scope : undefined }));
-      const { log, visible, attached } = await progress.race(result.evaluate(r => ({ log: r.log, visible: r.visible, attached: r.attached })));
-      if (log)
-        progress.log(log);
-      const success = { attached, detached: !attached, visible, hidden: !visible }[state];
-      if (!success) {
-        result.dispose();
-        return continuePolling;
-      }
-      if (options.omitReturnValue) {
-        result.dispose();
-        return null;
-      }
-      const element = state === 'attached' || state === 'visible' ? await progress.race(result.evaluateHandle(r => r.element)) : null;
-      result.dispose();
-      if (!element)
-        return null;
-      if ((options as any).__testHookBeforeAdoptNode)
-        await progress.race((options as any).__testHookBeforeAdoptNode());
-      try {
-        const mainContext = await progress.race(resolved.frame._mainContext());
-        return await progress.race(element._adoptTo(mainContext));
-      } catch (e) {
-        return continuePolling;
-      }
-    });
-    return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
+    		if ((options as any).visibility)
+    			throw new Error('options.visibility is not supported, did you mean options.state?');
+    		if ((options as any).waitFor && (options as any).waitFor !== 'visible')
+    			throw new Error('options.waitFor is not supported, did you mean options.state?');
+
+    		const { state = 'visible' } = options;
+    		if (!['attached', 'detached', 'visible', 'hidden'].includes(state))
+    			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, 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) {
+    				if (handle.parentNode instanceof dom.ElementHandle) {
+    					visible = await handle.parentNode.evaluateInUtility(([injected, node, { handle }]) => {
+    						return handle ? injected.utils.isElementVisible(handle) : false;
+    					}, { handle });
+    				} else {
+    					visible = await handle.parentNode.evaluate((injected, { handle }) => {
+    						return handle ? injected.utils.isElementVisible(handle) : false;
+    					}, { handle });
+    				}
+    			}
+
+    			const success = {
+    				attached,
+    				detached: !attached,
+    				visible,
+    				hidden: !visible
+    			}[state];
+    			if (!success) return "internal:continuepolling";
+    			if (options.omitReturnValue) return null;
+
+    			const element = state === 'attached' || state === 'visible' ? handle : null;
+    			if (!element) return null;
+    			if (options.__testHookBeforeAdoptNode) await options.__testHookBeforeAdoptNode();
+    			try {
+    				return element;
+    			} catch (e) {
+    				return "internal:continuepolling";
+    			}
+    		}, "returnOnNotResolved");
+
+    		const resultPromise = scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
+    		return resultPromise.catch(e => {
+    			if (this.isDetached() && (e as any)?.message?.includes('Execution context was destroyed'))
+    				throw new Error('Frame was detached');
+    			throw e;
+    		});
+    	
   }
 
   async dispatchEvent(progress: Progress, selector: string, type: string, eventInit: Object = {}, options: types.QueryOnSelectorOptions, scope?: dom.ElementHandle): Promise<void> {
-    await this._callOnElementOnceMatches(progress, selector, (injectedScript, element, data) => {
-      injectedScript.dispatchEvent(element, data.type, data.eventInit);
-    }, { type, eventInit }, { mainWorld: true, ...options }, scope);
+
+    		const eventInitHandles: js.JSHandle[] = [];
+    		const visited = new WeakSet();
+    		const collectHandles = (value: any) => {
+    			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 handlesFrame = eventInitHandles[0]?._context?.frame;
+    		const allHandlesFromSameFrame = eventInitHandles.length > 0 && eventInitHandles.every(handle => handle._context?.frame === handlesFrame);
+    		const canRetryInSecondaryContext = allHandlesFromSameFrame && (handlesFrame !== this || !selector.includes("internal:control=enter-frame"));
+    		const callback = (injectedScript, element, data) => {
+    			injectedScript.dispatchEvent(element, data.type, data.eventInit);
+    		};
+    		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: string, strict: boolean, expression: string, isFunction: boolean | undefined, arg: any, scope?: dom.ElementHandle): Promise<any> {
-    const handle = await this.selectors.query(selector, { strict }, scope);
-    if (!handle)
-      throw new Error(`Failed to find element matching selector "${selector}"`);
-    const result = await handle.evaluateExpression(expression, { isFunction }, arg);
-    handle.dispose();
-    return result;
+
+    		const handle = await this.selectors.query(selector, { strict }, scope);
+    		if (!handle)
+    			throw new Error('Failed to find element matching selector "' + selector + '"');
+    		const result = await handle.evaluateExpression(expression, { isFunction }, arg, true);
+    		handle.dispose();
+    		return result;
+    	
   }
 
-  async evalOnSelectorAll(selector: string, expression: string, isFunction: boolean | undefined, arg: any, scope?: dom.ElementHandle): Promise<any> {
-    const arrayHandle = await this.selectors.queryArrayInMainWorld(selector, scope);
-    const result = await arrayHandle.evaluateExpression(expression, { isFunction }, arg);
-    arrayHandle.dispose();
-    return result;
+  async evalOnSelectorAll(selector: string, expression: string, isFunction: boolean | undefined, arg: any, scope?: dom.ElementHandle, isolatedContext?: boolean): Promise<any> {
+
+    		const maxAttempts = 3;
+    		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    			try {
+    				isolatedContext = this.selectors._parseSelector(selector, { strict: false }).world !== "main" && isolatedContext;
+    				const arrayHandle = await this.selectors.queryArrayInMainWorld(selector, scope, isolatedContext);
+    				const result = await arrayHandle.evaluateExpression(expression, { isFunction }, arg, isolatedContext);
+    				arrayHandle.dispose();
+    				return result;
+    			} catch (e) {
+    				// Retry only on specific context mismatch errors, and only a bounded number of times.
+    				if ("JSHandles can be evaluated only in the context they were created!" !== e.message || attempt === maxAttempts) throw e;
+    				await new Promise(resolve => setTimeout(resolve, 50 * attempt));
+    			}
+    		}
+    	
   }
 
   async maskSelectors(selectors: ParsedSelector[], color: string): Promise<void> {
@@ -855,17 +983,34 @@
   }
 
   async querySelectorAll(selector: string): Promise<dom.ElementHandle<Element>[]> {
-    return this.selectors.queryAll(selector);
+
+    		const metadata = { internal: false, log: [], method: "querySelectorAll" };
+    		const progress = {
+    			log: message => metadata.log.push(message),
+    			metadata,
+    			race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
+    		}
+    		return await this._retryWithoutProgress(progress, selector, {strict: null, performActionPreChecks: false}, async (result) => {
+    			if (!result || !result[0]) return [];
+    			return Array.isArray(result[1]) ? result[1] : [];
+    		}, 'returnAll', null);
+    	
   }
 
   async queryCount(selector: string, options: any): Promise<number> {
-    try {
-      return await this.selectors.queryCount(selector, options);
-    } catch (e) {
-      if (this.isNonRetriableError(e))
-        throw e;
-      return 0;
-    }
+
+    		const metadata = { internal: false, log: [], method: "queryCount" };
+    		const progress = {
+    			log: message => metadata.log.push(message),
+    			metadata,
+    			race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
+    		}
+    		return await this._retryWithoutProgress(progress, selector, {strict: null, performActionPreChecks: false }, async (result) => {
+    			if (!result || !result[0])
+    				return 0;
+    			return Array.isArray(result[1]) ? result[1].length : 0;
+    		}, 'returnAll', null);
+    	
   }
 
   async content(): Promise<string> {
@@ -887,29 +1032,23 @@
   }
 
   async setContent(progress: Progress, html: string, options: types.NavigateOptions): Promise<void> {
-    const tag = `--playwright--set--content--${this._id}--${++this._setContentCounter}--`;
-    await this.raceNavigationAction(progress, async () => {
-      const waitUntil = options.waitUntil === undefined ? 'load' : options.waitUntil;
-      progress.log(`setting frame content, waiting until "${waitUntil}"`);
-      const context = await progress.race(this._utilityContext());
-      const tagPromise = new ManualPromise<void>();
-      this._page.frameManager._consoleMessageTags.set(tag, () => {
-        // Clear lifecycle right after document.open() - see 'tag' below.
-        this._onClearLifecycle();
-        tagPromise.resolve();
-      });
-      const lifecyclePromise = progress.race(tagPromise).then(() => this.waitForLoadState(progress, waitUntil));
-      const contentPromise = progress.race(context.evaluate(({ html, tag }) => {
-        document.open();
-        console.debug(tag);  // eslint-disable-line no-console
-        document.write(html);
-        document.close();
-      }, { html, tag }));
-      await Promise.all([contentPromise, lifecyclePromise]);
-      return null;
-    }).finally(() => {
-      this._page.frameManager._consoleMessageTags.delete(tag);
-    });
+
+        await this.raceNavigationAction(progress, async () => {
+          const waitUntil = options.waitUntil === void 0 ? "load" : options.waitUntil;
+          progress.log(`setting frame content, waiting until "${waitUntil}"`);
+          const lifecyclePromise = new Promise((resolve, reject) => {
+            this._onClearLifecycle();
+            this.waitForLoadState(progress, waitUntil).then(resolve).catch(reject);
+          });
+          const setContentPromise = this._page.delegate._sessionForFrame(this)._client.send("Page.setDocumentContent", {
+            frameId: this._id,
+            html
+          });
+          await Promise.all([setContentPromise, lifecyclePromise]);
+
+          return null;
+        });
+    	
   }
 
   name(): string {
@@ -1101,60 +1240,14 @@
     progress: Progress,
     selector: string,
     options: { strict?: boolean, noAutoWaiting?: boolean, force?: boolean, performActionPreChecks?: boolean },
-    action: (handle: dom.ElementHandle<Element>) => Promise<R | 'error:notconnected'>): Promise<R> {
-    progress.log(`waiting for ${this._asLocator(selector)}`);
-    const noAutoWaiting = (options as any).__testHookNoAutoWaiting ?? options.noAutoWaiting;
-    const performActionPreChecks = (options.performActionPreChecks ?? !options.force) && !noAutoWaiting;
-    return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-      if (performActionPreChecks)
-        await this._page.performActionPreChecks(progress);
+    action: (handle: dom.ElementHandle<Element>) => Promise<R | 'error:notconnected'>, returnAction: 'returnOnNotResolved' | 'returnAll' | undefined): Promise<R> {
 
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, { strict: options.strict }));
-      if (!resolved) {
-        if (noAutoWaiting)
-          throw new dom.NonRecoverableDOMError('Element(s) not found');
-        return continuePolling;
-      }
-      const result = await progress.race(resolved.injected.evaluateHandle((injected, { info, callId }) => {
-        const elements = injected.querySelectorAll(info.parsed, document);
-        if (callId)
-          injected.markTargetElements(new Set(elements), callId);
-        const element = elements[0] as Element | undefined;
-        let log = '';
-        if (elements.length > 1) {
-          if (info.strict)
-            throw injected.strictModeViolationError(info.parsed, elements);
-          log = `  locator resolved to ${elements.length} elements. Proceeding with the first one: ${injected.previewNode(elements[0])}`;
-        } else if (element) {
-          log = `  locator resolved to ${injected.previewNode(element)}`;
-        }
-        injected.checkDeprecatedSelectorUsage(info.parsed, elements);
-        return { log, success: !!element, element };
-      }, { info: resolved.info, callId: progress.metadata.id }));
-      const { log, success } = await progress.race(result.evaluate(r => ({ log: r.log, success: r.success })));
-      if (log)
-        progress.log(log);
-      if (!success) {
-        if (noAutoWaiting)
-          throw new dom.NonRecoverableDOMError('Element(s) not found');
-        result.dispose();
-        return continuePolling;
-      }
-      const element = await progress.race(result.evaluateHandle(r => r.element)) as dom.ElementHandle<Element>;
-      result.dispose();
-      try {
-        const result = await action(element);
-        if (result === 'error:notconnected') {
-          if (noAutoWaiting)
-            throw new dom.NonRecoverableDOMError('Element is not attached to the DOM');
-          progress.log('element was detached from the DOM, retrying');
-          return continuePolling;
-        }
-        return result;
-      } finally {
-        element?.dispose();
-      }
-    });
+    			if (!(options as any)?.__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, options as any, action as any, returnAction, continuePolling);
+    			});
+    		
   }
 
   async rafrafTimeoutScreenshotElementWithProgress(progress: Progress, selector: string, timeout: number, options: ScreenshotOptions): Promise<Buffer> {
@@ -1307,20 +1400,61 @@
   }
 
   async isVisibleInternal(progress: Progress, selector: string, options: types.StrictOptions = {}, scope?: dom.ElementHandle): Promise<boolean> {
-    try {
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
-      if (!resolved)
-        return false;
-      return await progress.race(resolved.injected.evaluate((injected, { info, root }) => {
-        const element = injected.querySelector(info.parsed, root || document, info.strict);
-        const state = element ? injected.elementState(element, 'visible') : { matches: false, received: 'error:notconnected' };
-        return state.matches;
-      }, { info: resolved.info, root: resolved.frame === this ? scope : undefined }));
-    } catch (e) {
-      if (this.isNonRetriableError(e))
-        throw e;
-      return false;
-    }
+
+    		try {
+    			const metadata = { internal: false, log: [], method: "isVisible" };
+    			const progress = {
+    				log: message => metadata.log.push(message),
+    				metadata,
+    				race: (promise) => Promise.race(Array.isArray(promise) ? promise : [promise])
+    			}
+    			progress.log("waiting for " + this._asLocator(selector));
+    			if (selector === ":scope") {
+    				const scopeParentNode = scope.parentNode || scope;
+    				if (scopeParentNode instanceof dom.ElementHandle) {
+    					return await scopeParentNode.evaluateInUtility(([injected, node, { scope: handle2 }]) => {
+    						const state = handle2 ? injected.elementState(handle2, "visible") : {
+    							matches: false,
+    							received: "error:notconnected"
+    						};
+    						return state.matches;
+    					}, { scope });
+    				} else {
+    					return await scopeParentNode.evaluate((injected, node, { scope: handle2 }) => {
+    						const state = handle2 ? injected.elementState(handle2, "visible") : {
+    							matches: false,
+    							received: "error:notconnected"
+    						};
+    						return state.matches;
+    					}, { scope });
+    				}
+    			} else {
+    				return await this._retryWithoutProgress(progress, selector, { ...options, performActionPreChecks: false}, async (handle) => {
+    					if (!handle) return false;
+    					if (handle.parentNode instanceof dom.ElementHandle) {
+    						return await handle.parentNode.evaluateInUtility(([injected, node, { handle: handle2 }]) => {
+    							const state = handle2 ? injected.elementState(handle2, "visible") : {
+    								matches: false,
+    								received: "error:notconnected"
+    							};
+    							return state.matches;
+    						}, { handle });
+    					} else {
+    						return await handle.parentNode.evaluate((injected, { handle: handle2 }) => {
+    							const state = handle2 ? injected.elementState(handle2, "visible") : {
+    								matches: false,
+    								received: "error:notconnected"
+    							};
+    							return state.matches;
+    						}, { handle });
+    					}
+    				}, "returnOnNotResolved", null);
+    			}
+    		} catch (e) {
+    			if (this.isNonRetriableError(e)) throw e;
+    			return false;
+    		}
+    	
   }
 
   async isHidden(progress: Progress, selector: string, options: types.StrictOptions = {}, scope?: dom.ElementHandle): Promise<boolean> {
@@ -1439,47 +1573,96 @@
   }
 
   private async _expectInternal(progress: Progress, selector: string | undefined, options: FrameExpectParams, lastIntermediateResult: { received?: any, isSet: boolean, errorMessage?: string }, noAbort: boolean) {
-    // The first expect check, a.k.a. one-shot, always finishes - even when progress is aborted.
-    const race = <T>(p: Promise<T>) => noAbort ? p : progress.race(p);
-    const selectorInFrame = selector ? await race(this.selectors.resolveFrameForSelector(selector, { strict: true })) : undefined;
 
-    const { frame, info } = selectorInFrame || { frame: this, info: undefined };
-    const world = options.expression === 'to.have.property' ? 'main' : (info?.world ?? 'utility');
-    const context = await race(frame._context(world));
-    const injected = await race(context.injectedScript());
+    		// The first expect check, a.k.a. one-shot, always finishes - even when progress is aborted.
+    		const race = (p) => noAbort ? p : progress.race(p);
+    		const isArray = options.expression === 'to.have.count' || options.expression.endsWith('.array');
+    		var log, matches, received, missingReceived;
+    		if (selector) {
+    			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 };
+    					// expect(locator).toBeHidden() passes when there is no element.
+    					if (!options.isNot && options.expression === 'to.be.hidden')
+    						return { matches: true };
+    					// expect(locator).not.toBeVisible() passes when there is no element.
+    					if (options.isNot && options.expression === 'to.be.visible')
+    						return { matches: false };
+    					// expect(locator).toBeAttached({ attached: false }) passes when there is no element.
+    					if (!options.isNot && options.expression === 'to.be.detached')
+    						return { matches: true };
+    					// expect(locator).not.toBeAttached() passes when there is no element.
+    					if (options.isNot && options.expression === 'to.be.attached')
+    						return { matches: false };
+    					// expect(locator).not.toBeInViewport() passes when there is no element.
+    					if (options.isNot && options.expression === 'to.be.in.viewport')
+    						return { matches: false };
+    					// expect(locator).toHaveText([]) pass when there is no element.
+    					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: [] };
+    					}
+    					// When none of the above applies, expect does not match.
+    					return { matches: options.isNot, missingReceived: true };
+    				}
 
-    const { log, matches, received, missingReceived } = await race(injected.evaluate(async (injected, { info, options, callId }) => {
-      const elements = info ? injected.querySelectorAll(info.parsed, document) : [];
-      if (callId)
-        injected.markTargetElements(new Set(elements), callId);
-      const isArray = options.expression === 'to.have.count' || options.expression.endsWith('.array');
-      let log = '';
-      if (isArray)
-        log = `  locator resolved to ${elements.length} element${elements.length === 1 ? '' : 's'}`;
-      else if (elements.length > 1)
-        throw injected.strictModeViolationError(info!.parsed, elements);
-      else if (elements.length)
-        log = `  locator resolved to ${injected.previewNode(elements[0])}`;
-      if (info)
-        injected.checkDeprecatedSelectorUsage(info.parsed, elements);
-      return { log, ...await injected.expect(elements[0], options, elements) };
-    }, { info, options, callId: progress.metadata.id }));
+    				const handle = result[0];
+    				const handles = result[1];
 
-    if (log)
-      progress.log(log);
-    // Note: missingReceived avoids `unexpected value "undefined"` when element was not found.
-    if (matches === options.isNot) {
-      if (missingReceived) {
-        lastIntermediateResult.errorMessage = 'Error: element(s) not found';
-      } else {
-        lastIntermediateResult.errorMessage = undefined;
-        lastIntermediateResult.received = received;
-      }
-      lastIntermediateResult.isSet = true;
-      if (!missingReceived && !Array.isArray(received))
-        progress.log(`  unexpected value "${renderUnexpectedValue(options.expression, received)}"`);
-    }
-    return { matches, received };
+    				if (handle.parentNode instanceof dom.ElementHandle) {
+    					return await handle.parentNode.evaluateInUtility(async ([injected, node, { handle, options, handles }]) => {
+    						return await injected.expect(handle, options, handles);
+    					}, { handle, options, handles });
+    				} else {
+    					return await handle.parentNode.evaluate(async (injected, { handle, options, handles }) => {
+    						return await injected.expect(handle, options, handles);
+    					}, { handle, options, handles });
+    				}
+    			}
+
+    			if (noAbort) {
+    				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, { strict: !isArray, performActionPreChecks: false, __patchrightSkipRetryLogWaiting: true } as any, action, 'returnAll'));
+    			}
+    		} else {
+    			const world = options.expression === 'to.have.property' ? 'main' : 'utility';
+    			const context = await race(this._context(world));
+    			const injected = await race(context.injectedScript());
+    			var { matches, received, missingReceived } = await race(injected.evaluate(async (injected, { options, callId }) => {
+    				return { ...await injected.expect(undefined, options, []) };
+    			}, { options, callId: progress.metadata.id }));
+    		}
+
+
+    		if (log)
+    			progress.log(log);
+    		// Note: missingReceived avoids `unexpected value "undefined"` when element was not found.
+    		if (matches === options.isNot) {
+    			if (missingReceived) {
+    				lastIntermediateResult.errorMessage = 'Error: element(s) not found';
+    			} else {
+    				lastIntermediateResult.errorMessage = undefined;
+    				lastIntermediateResult.received = received;
+    			}
+    			lastIntermediateResult.isSet = true;
+    			if (!missingReceived) {
+    				const rendered = renderUnexpectedValue(options.expression, received);
+    				if (rendered !== undefined)
+    					progress.log('  unexpected value "' + rendered + '"');
+    			}
+    		}
+    		return { matches, received };
+    	
   }
 
   async waitForFunctionExpression<R>(progress: Progress, expression: string, isFunction: boolean | undefined, arg: any, options: { pollingInterval?: number }, world: types.World = 'main'): Promise<js.SmartHandle<R>> {
@@ -1538,7 +1721,7 @@
         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) {
         // Note: it is important to await "abort()" to prevent any side effects
         // after this method returns.
@@ -1591,42 +1774,129 @@
   }
 
   _onDetached() {
-    this._stopNetworkIdleTimer();
-    this._detachedScope.close(new Error('Frame was detached'));
-    for (const data of this._contextData.values()) {
-      if (data.context)
-        data.context.contextDestroyed('Frame was detached');
-      data.contextPromise.resolve({ destroyedReason: 'Frame was detached' });
-    }
-    if (this._parentFrame)
-      this._parentFrame._childFrames.delete(this);
-    this._parentFrame = null;
+
+    		this._stopNetworkIdleTimer();
+    		this._detachedScope.close(new Error('Frame was detached'));
+    		for (const data of this._contextData.values()) {
+    			if (data.context)
+    				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;
+    	
   }
 
   private async _callOnElementOnceMatches<T, R>(progress: Progress, selector: string, body: ElementCallback<T, R>, taskData: T, options: types.StrictOptions & { mainWorld?: boolean }, scope?: dom.ElementHandle): Promise<R> {
-    const callbackText = body.toString();
-    progress.log(`waiting for ${this._asLocator(selector)}`);
-    const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-      const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
-      if (!resolved)
-        return continuePolling;
-      const { log, success, value } = await progress.race(resolved.injected.evaluate((injected, { info, callbackText, taskData, callId, root }) => {
-        const callback = injected.eval(callbackText) as ElementCallback<T, R>;
-        const element = injected.querySelector(info.parsed, root || document, info.strict);
-        if (!element)
-          return { success: false };
-        const log = `  locator resolved to ${injected.previewNode(element)}`;
-        if (callId)
-          injected.markTargetElements(new Set([element]), callId);
-        return { log, success: true, value: callback(injected, element, taskData as T) };
-      }, { info: resolved.info, callbackText, taskData, callId: progress.metadata.id, root: resolved.frame === this ? scope : undefined }));
-      if (log)
-        progress.log(log);
-      if (!success)
-        return continuePolling;
-      return value!;
-    });
-    return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
+
+    		const callbackText = body.toString();
+    		progress.log("waiting for " + this._asLocator(selector));
+    		var promise;
+    		if (selector === ":scope") {
+    			const scopeParentNode = scope.parentNode || scope;
+    			if (scopeParentNode instanceof dom.ElementHandle) {
+    				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);
+    					return callback(injected, handle2, taskData2);
+    				}, {
+    					callbackText,
+    					scope,
+    					taskData
+    				});
+    			}
+    		} else {
+
+    			promise = this._retryWithProgressIfNotConnected(progress, selector, { ...options, performActionPreChecks: false }, async (handle) => {
+    				if (handle.parentNode instanceof dom.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();
+    						}
+    					}
+
+    					// Handling dispatch_event's in isolated and Main Contexts
+    					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);
+    						return callback(injected, handle2, taskData2);
+    					}, {
+    						callbackText,
+    						handle,
+    						taskData
+    					});
+    				} else {
+    					return await handle.parentNode.evaluate((injected, { callbackText: callbackText2, handle: handle2, taskData: taskData2 }) => {
+    						const callback = injected.eval(callbackText2);
+    						return callback(injected, handle2, taskData2);
+    					}, {
+    						callbackText,
+    						handle,
+    						taskData
+    					});
+    				}
+    			})
+    		}
+    		return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
+    	
   }
 
   private _setContext(world: types.World, context: dom.FrameExecutionContext | null) {
@@ -1722,6 +1992,325 @@
   private _asLocator(selector: string) {
     return asLocator(this._page.browserContext._browser.sdkLanguage(), selector);
   }
+
+  _isolatedWorld: dom.FrameExecutionContext;
+  _mainWorld: dom.FrameExecutionContext;
+  _iframeWorld: dom.FrameExecutionContext;
+
+  async _getFrameMainFrameContextId(client: CRSession): Promise<number> {
+
+    		try {
+    		  const frameOwner = await client._sendMayFail("DOM.getFrameOwner", { frameId: this._id });
+    		  if (!frameOwner?.nodeId)
+    		    return 0;
+
+    		  const describedNode = await client._sendMayFail("DOM.describeNode", { backendNodeId: frameOwner.backendNodeId });
+    		  if (!describedNode?.node.contentDocument)
+    		    return 0;
+
+    		  const resolvedNode = await client._sendMayFail("DOM.resolveNode", { backendNodeId: describedNode.node.contentDocument.backendNodeId });
+    		  if (!resolvedNode?.object?.objectId)
+    		    return 0;
+
+    		  return parseInt(resolvedNode.object.objectId.split(".")[1], 10);
+    		} catch (e) {}
+    		return 0;
+    	
+  }
+
+  async _retryWithoutProgress(progress: Progress, selector: string, options: { performActionPreChecks: boolean; strict?: boolean | null; state?: 'attached' | 'detached' | 'visible' | 'hidden'; noAutoWaiting?: boolean; __testHookNoAutoWaiting?: boolean; __patchrightWaitForSelector?: boolean; __patchrightInitialScope?: dom.ElementHandle; __patchrightSkipRetryLogWaiting?: boolean }, action: (result: dom.ElementHandle | [dom.ElementHandle, dom.ElementHandle[]] | null) => Promise<unknown>, returnAction: 'returnOnNotResolved' | 'returnAll' | undefined, continuePolling: symbol) {
+
+    		if (options.performActionPreChecks)
+    			await this._page.performActionPreChecks(progress);
+
+    		const resolved = await this.selectors.resolveInjectedForSelector(
+    			selector,
+    			{ strict: options.strict },
+    			 (options as any).__patchrightInitialScope
+    		);
+
+    		if (!resolved) {
+    			if (returnAction === 'returnOnNotResolved' || returnAction === 'returnAll') {
+    				const result = await action(null);
+    				return result === "internal:continuepolling" ? continuePolling : result;
+    			}
+    			return continuePolling;
+    		}
+
+    		const utilityContext = await resolved.frame._utilityContext();
+    		const mainContext = await resolved.frame._mainContext();
+    		let client;
+    		try {
+    			client = this._page.delegate._sessionForFrame(resolved.frame)._client;
+    		} catch (e) {
+    			client = this._page.delegate._mainFrameSession._client;
+    		}
+
+    		const documentNode = await client._sendMayFail('Runtime.evaluate', {
+    			expression: "document",
+    			serializationOptions: { serialization: "idOnly" },
+    			contextId: utilityContext.delegate._contextId,
+    		});
+    		if (!documentNode)
+    			return continuePolling;
+
+    		let initialScope = new dom.ElementHandle(utilityContext, documentNode.result.objectId);
+
+    		if ((resolved as any).scope) {
+    			const scopeObjectId = (resolved as any).scope._objectId;
+    			if (scopeObjectId) {
+    				const describeResult = await client._sendMayFail('DOM.describeNode', {
+    					objectId: scopeObjectId,
+    				});
+    				const backendNodeId = describeResult?.node?.backendNodeId;
+
+    				if (backendNodeId) {
+    					const scopeInUtility = await client._sendMayFail('DOM.resolveNode', {
+    						backendNodeId,
+    						executionContextId: utilityContext.delegate._contextId
+    					});
+
+    					if (scopeInUtility?.object?.objectId) {
+    						initialScope = new dom.ElementHandle(utilityContext, scopeInUtility.object.objectId);
+    					}
+    				}
+    			}
+    		}
+    		(progress as any).__patchrightInitialScope = (resolved as any).scope;
+
+    		// Save parsed selector before _customFindElementsByParsed mutates it via parts.shift()
+    		const parsedSnapshot = (options as any).__patchrightWaitForSelector ? JSON.parse(JSON.stringify(resolved.info.parsed)) : null;
+    		let currentScopingElements;
+    		try {
+    			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 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 as any).__testHookNoAutoWaiting || (options as any).noAutoWaiting)
+    				throw new dom.NonRecoverableDOMError('Element(s) not found');
+
+    			// CDP-based element search is non-atomic and can temporarily miss
+    			// elements during DOM mutations. Verify element absence in-page before reporting
+    			// "not found" to the waitForSelector callback.
+    			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 result = await action(null);
+    				return result === "internal:continuepolling" ? continuePolling : result;
+    			}
+    			return continuePolling;
+    		}
+
+    		const resultElement = currentScopingElements[0];
+    		await resultElement._initializePreview().catch(() => {});
+
+    		let visibilityQualifier = '';
+    		if (options && (options as any).__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, {
+    					info,
+    					elements
+    				}) => {
+    					throw injected.strictModeViolationError(info.parsed, elements);
+    				}, {
+    					info: resolved.info,
+    					elements: currentScopingElements
+    				}));
+    			}
+    			progress.log("  locator resolved to " + currentScopingElements.length + " elements. Proceeding with the first one: " + resultElement.preview());
+    		} else if (resultElement) {
+    			progress.log("  locator resolved to " + (visibilityQualifier ? visibilityQualifier + " " : "") + resultElement.preview().replace("JSHandle@", ""));
+    		}
+
+    		try {
+    			var result = null;
+    			if (returnAction === 'returnAll') {
+    				result = await action([resultElement, currentScopingElements]);
+    			} else {
+    				result = await action(resultElement);
+    			}
+    			if (result === 'error:notconnected') {
+    				progress.log('element was detached from the DOM, retrying');
+    				return continuePolling;
+    			} else if (result === 'internal:continuepolling') {
+    				return continuePolling;
+    			}
+    			// Verify no visible elements exist before accepting a null result to avoid stale CDP handles during mutations.
+    			if (parsedSnapshot && result === null && ((options as any).state === 'hidden' || (options as any).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 {}
+    	
+  }
+
+  async _customFindElementsByParsed(resolved: { injected: js.JSHandle<InjectedScript>, info: { parsed: ParsedSelector, strict: boolean }, frame: Frame, scope?: dom.ElementHandle }, client: CRSession, context: dom.FrameExecutionContext, documentScope: dom.ElementHandle, progress: Progress, parsed: ParsedSelector) {
+
+    		var parsedEdits = { ...parsed };
+    		// Note: We start scoping at document level
+    		var currentScopingElements = [documentScope];
+
+    		for (const part of [...parsed.parts]) {
+    			parsedEdits.parts = [part];
+    			var elements = [];
+
+    			if (part.name === "nth") {
+    				const partNth = Number(part.body);
+    				// Check if any Elements are currently scoped, else return empty array to continue polling
+    				if (currentScopingElements.length == 0)
+    					return [];
+
+    				if (partNth > currentScopingElements.length-1 || partNth < -(currentScopingElements.length-1)) {
+    					if (parsed.capture !== undefined)
+    						throw new Error("Can't query n-th element in a request with the capture.");
+    					return [];
+    				}
+    				currentScopingElements = [currentScopingElements.at(partNth)];
+    				continue;
+    			} else if (part.name === "internal:or") {
+    				var orredElements = await this._customFindElementsByParsed(resolved, client, context, documentScope, progress, part.body.parsed);
+    				elements = [...currentScopingElements, ...orredElements];
+    			} else if (part.name == "internal:and") {
+    				var andedElements = await this._customFindElementsByParsed(resolved, client, context, documentScope, progress, part.body.parsed);
+    				const backendNodeIds = new Set(andedElements.map(elem => elem.backendNodeId));
+    				elements = currentScopingElements.filter(elem => backendNodeIds.has(elem.backendNodeId));
+    			} else {
+    				for (const scope of currentScopingElements) {
+    					const describedScope = await client.send("DOM.describeNode", {
+    						objectId: scope._objectId,
+    						depth: -1,
+    						pierce: true
+    					});
+
+    					let findClosedShadowRoots = function(node, results = []) {
+    						if (!node || typeof node !== "object") return results;
+    						if (node.shadowRoots && Array.isArray(node.shadowRoots)) {
+    							for (const shadowRoot of node.shadowRoots) {
+    								if (shadowRoot.shadowRootType === "closed" && shadowRoot.backendNodeId) {
+    									results.push(shadowRoot.backendNodeId);
+    								}
+    								findClosedShadowRoots(shadowRoot, results);
+    							}
+    						}
+    						if (node.nodeName !== "IFRAME" && node.children && Array.isArray(node.children)) {
+    							for (const child of node.children) {
+    								findClosedShadowRoots(child, results);
+    							}
+    						}
+    						return results;
+    					};
+    					var shadowRootBackendIds = findClosedShadowRoots(describedScope.node);
+
+    					const shadowRoots = await Promise.all(
+    						shadowRootBackendIds.map(async backendNodeId => {
+    							const resolved = await client.send("DOM.resolveNode", {
+    								backendNodeId,
+    								contextId: context.delegate._contextId,
+    							});
+    							return new dom.ElementHandle(context, resolved.object.objectId);
+    						})
+    					);
+
+    					// Elements Queryed in the "current round"
+    					const queryGroups: { handles: any; parentNode: any }[] = [];
+    					for (var shadowRoot of shadowRoots) {
+    						const shadowHandles = await shadowRoot.evaluateHandleInUtility(
+    							([injected, node, { parsed, callId }]) => {
+    							 	const elements = injected.querySelectorAll(parsed, node);
+    								if (callId)
+    									injected.markTargetElements(new Set(elements), callId);
+    								return elements;
+    							}, {
+    								parsed: parsedEdits,
+    								callId: progress.metadata.id
+    							}
+    						);
+    						queryGroups.push({ handles: shadowHandles, parentNode: shadowRoot });
+    					}
+
+    					// Document Root Elements (not in CSR)
+    					const rootHandles = await scope.evaluateHandleInUtility(
+    						([injected, node, { parsed, callId }]) => {
+    						 	const elements = injected.querySelectorAll(parsed, node);
+    							if (callId)
+    								injected.markTargetElements(new Set(elements), callId);
+    							return elements;
+    						}, {
+    							parsed: parsedEdits,
+    							callId: progress.metadata.id
+    						}
+    					);
+    					queryGroups.push({ handles: rootHandles, parentNode: scope });
+
+    					// Querying and Sorting the elements by their backendNodeId
+    					for (const { handles, parentNode } of queryGroups) {
+    						const handlesAmount = await (await handles.getProperty("length")).jsonValue();
+    						for (var i = 0; i < handlesAmount; i++) {
+    						  if (parentNode instanceof dom.ElementHandle) {
+    								var element = await parentNode.evaluateHandleInUtility(
+    									([injected, node, { i, handles: elems }]) => elems[i],
+    									{ i, handles }
+    								);
+    							} else {
+    								var element = await parentNode.evaluateHandle(
+    									(injected, { i, handles: elems }) => elems[i],
+    									{ i, handles }
+    								);
+    							}
+
+    							// For other Functions/Utilities
+    							element.parentNode = parentNode;
+    							const resolvedElement = await client.send("DOM.describeNode", { objectId: element._objectId, depth: -1 });
+    							element.backendNodeId = resolvedElement.node.backendNodeId;
+    							element.nodePosition = await this.selectors._findElementPositionInDomTree(element, describedScope.node, context, "");
+    							elements.push(element);
+    						}
+    					}
+    				}
+    			}
+
+    			// Sorting elements by their nodePosition, which is a index to the Element in the DOM tree
+    			const getParts = (pos) => (pos || '').split('.').filter(Boolean).map(Number);
+    			elements.sort((a, b) => {
+    				const partsA = getParts(a.nodePosition);
+    				const partsB = getParts(b.nodePosition);
+
+    				for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    					const diff = (partsA[i] ?? -1) - (partsB[i] ?? -1);
+    					if (diff !== 0) return diff;
+    				}
+    				return 0;
+    			});
+
+    			// Remove duplicates by backendNodeId, keeping the first occurrence
+    			currentScopingElements = Array.from(
+    				new Map(elements.map(e => [e.backendNodeId, e])).values()
+    			);
+    		}
+
+    		return currentScopingElements;
+    	
+  }
 }
 
 class SignalBarrier {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/javascript.ts patchright/packages/playwright-core/src/server/javascript.ts
---
+++
@@ -22,6 +22,7 @@
 
 import type * as dom from './dom';
 import type { UtilityScript } from '@injected/utilityScript';
+import * as domValue from "./dom";
 
 interface TaggedAsJSHandle<T> {
   __jshandle: T;
@@ -149,17 +150,45 @@
     return evaluate(this._context, false /* returnByValue */, pageFunction, this, arg);
   }
 
-  async evaluateExpression(expression: string, options: { isFunction?: boolean }, arg: any) {
-    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: true }, this, arg);
-    await this._context.doSlowMo();
-    return value;
-  }
+  async evaluateExpression(expression: string, options: { isFunction?: boolean }, arg: any, isolatedContext?: boolean) {
 
-  async evaluateExpressionHandle(expression: string, options: { isFunction?: boolean }, arg: any): Promise<JSHandle<any>> {
-    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: false }, this, arg);
-    await this._context.doSlowMo();
-    return value;
-  }
+    		let context = this._context;
+    		if (context instanceof domValue.FrameExecutionContext) {
+    			const frame = context.frame;
+    			if (frame) {
+    				if (isolatedContext === true)
+    					context = await frame._utilityContext();
+    				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;
+    }
+
+  async evaluateExpressionHandle(expression: string, options: { isFunction?: boolean }, arg: any, isolatedContext?: boolean): Promise<JSHandle<any>> {
+
+    		let context = this._context;
+    		if (context instanceof domValue.FrameExecutionContext) {
+    			const frame = context.frame;
+    			if (frame) {
+    				if (isolatedContext === true)
+    					context = await frame._utilityContext();
+    				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;
+    }
 
   async getProperty(propertyName: string): Promise<JSHandle> {
     const objectHandle = await this.evaluateHandle((object: any, propertyName) => {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/launchApp.ts patchright/packages/playwright-core/src/server/launchApp.ts
---
+++
@@ -117,7 +117,8 @@
             return;
           Object.entries(settings).map(([k, v]) => localStorage[k] = v);
           (window as any).saveSettings = () => {
-            (window as any)._saveSerializedSettings(JSON.stringify({ ...localStorage }));
+            if (typeof (window as any)._saveSerializedSettings === 'function')
+				(window as any)._saveSerializedSettings(JSON.stringify({ ...localStorage }));
           };
         })})(${settings});
     `);
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/page.ts patchright/packages/playwright-core/src/server/page.ts
---
+++
@@ -51,6 +51,8 @@
 import type * as channels from '@protocol/channels';
 import type { BindingPayload } from '@injected/bindingsController';
 import type { SelectorInfo } from './frameSelectors';
+import * as domValue from "./dom";
+import { createPageBindingScript, deliverBindingResult, takeBindingHandle } from "./pageBinding";
 
 export interface PageDelegate {
   readonly rawMouse: input.RawMouse;
@@ -332,21 +334,16 @@
   }
 
   async exposeBinding(progress: Progress, name: string, needsHandle: boolean, playwrightBinding: frames.FunctionWithSource): Promise<PageBinding> {
-    if (this._pageBindings.has(name))
-      throw new Error(`Function "${name}" has been already registered`);
-    if (this.browserContext._pageBindings.has(name))
-      throw new Error(`Function "${name}" has been already registered in the browser context`);
-    await progress.race(this.browserContext.exposePlaywrightBindingIfNeeded());
-    const binding = new PageBinding(this, name, playwrightBinding, needsHandle);
-    this._pageBindings.set(name, binding);
-    try {
-      await progress.race(this.delegate.addInitScript(binding.initScript));
-      await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, 'main'));
-      return binding;
-    } catch (error) {
-      this._pageBindings.delete(name);
-      throw error;
-    }
+
+    		if (this._pageBindings.has(name))
+    			throw new Error(`Function "${name}" has been already registered`);
+    		if (this.browserContext._pageBindings.has(name))
+    			throw new Error(`Function "${name}" has been already registered in the browser context`);
+    		const binding = new PageBinding(this, name, playwrightBinding, needsHandle);
+    		this._pageBindings.set(name, binding);
+    		await this.delegate.exposeBinding(binding);
+    		return binding;
+    	
   }
 
   async removeExposedBinding(binding: PageBinding) {
@@ -870,13 +867,6 @@
     }
   }
 
-  allInitScripts() {
-    const bindings = [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()].map(binding => binding.initScript);
-    if (this.browserContext.bindingsInitScript)
-      bindings.unshift(this.browserContext.bindingsInitScript);
-    return [...bindings, ...this.browserContext.initScripts, ...this.initScripts];
-  }
-
   getBinding(name: string) {
     return this._pageBindings.get(name) || this.browserContext._pageBindings.get(name);
   }
@@ -899,6 +889,12 @@
   async setDockTile(image: Buffer) {
     await this.delegate.setDockTile(image);
   }
+
+  allBindings() {
+
+    		return [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()];
+    	
+  }
 }
 
 export const WorkerEvent = {
@@ -953,83 +949,119 @@
     this.openScope.close(new Error('Worker closed'));
   }
 
-  async evaluateExpression(expression: string, isFunction: boolean | undefined, arg: any): Promise<any> {
-    return js.evaluateExpression(await this._executionContextPromise, expression, { returnByValue: true, isFunction }, arg);
-  }
+  async evaluateExpression(expression: string, isFunction: boolean | undefined, arg: any, isolatedContext?: boolean): Promise<any> {
 
-  async evaluateExpressionHandle(expression: string, isFunction: boolean | undefined, arg: any): Promise<any> {
-    return js.evaluateExpression(await this._executionContextPromise, expression, { returnByValue: false, isFunction }, arg);
-  }
+    			let context = await this._executionContextPromise;
+    			if (context instanceof domValue.FrameExecutionContext) {
+    				const frame = context.frame;
+    				if (frame) {
+    					if (isolatedContext) context = await frame._utilityContext();
+    					else if (!isolatedContext) context = await frame._mainContext();
+    				}
+    			}
+    		
+      return js.evaluateExpression(context, expression, { returnByValue: true, isFunction }, arg);
+    }
+
+  async evaluateExpressionHandle(expression: string, isFunction: boolean | undefined, arg: any, isolatedContext?: boolean): Promise<any> {
+
+    			let context = await this._executionContextPromise;
+    			if (context instanceof domValue.FrameExecutionContext) {
+    				const frame = context.frame;
+    				if (frame) {
+    					if (isolatedContext) context = await frame._utilityContext();
+    					else if (!isolatedContext) context = await frame._mainContext();
+    				}
+    			}
+    		
+      return js.evaluateExpression(context, expression, { returnByValue: false, isFunction }, arg);
+    }
 }
 
-export class PageBinding extends DisposableObject {
-  private static kController = '__playwright__binding__controller__';
-  static kBindingName = '__playwright__binding__';
 
-  static createInitScript(browserContext: BrowserContext): InitScript {
-    return new InitScript(browserContext, `
-      (() => {
-        const module = {};
-        ${rawBindingsControllerSource.source}
-        const property = '${PageBinding.kController}';
-        if (!globalThis[property])
-          globalThis[property] = new (module.exports.BindingsController())(globalThis, '${PageBinding.kBindingName}');
-      })();
-    `);
-  }
+		export class PageBinding extends DisposableObject {
+			readonly source: string;
+			readonly name: string;
+			readonly playwrightFunction: frames.FunctionWithSource;
+			readonly initScript: InitScript;
+			readonly needsHandle: boolean;
+			readonly cleanupScript: string;
+			forClient?: unknown;
 
-  readonly name: string;
-  readonly playwrightFunction: frames.FunctionWithSource;
-  readonly initScript: InitScript;
-  readonly needsHandle: boolean;
-  readonly cleanupScript: string;
-  forClient?: unknown;
+			constructor(parent: BrowserContext | Page, name: string, playwrightFunction: frames.FunctionWithSource, needsHandle: boolean) {
+				super(parent);
+				this.name = name;
+				this.playwrightFunction = playwrightFunction;
+				this.initScript = new InitScript(parent, createPageBindingScript(name, needsHandle));
+				this.source = this.initScript.source;
+				this.cleanupScript = `delete globalThis[${JSON.stringify(name)}];`;
+				this.needsHandle = needsHandle;
+			}
 
-  constructor(parent: BrowserContext | Page, name: string, playwrightFunction: frames.FunctionWithSource, needsHandle: boolean) {
-    super(parent);
-    this.name = name;
-    this.playwrightFunction = playwrightFunction;
-    this.initScript = new InitScript(parent, `globalThis['${PageBinding.kController}'].addBinding(${JSON.stringify(name)}, ${needsHandle})`);
-    this.needsHandle = needsHandle;
-    this.cleanupScript = `globalThis['${PageBinding.kController}'].removeBinding(${JSON.stringify(name)})`;
-  }
+			static async dispatch(page: Page, payload: string, context: dom.FrameExecutionContext) {
+				const { name, seq, serializedArgs } = JSON.parse(payload) as BindingPayload;
 
-  static async dispatch(page: Page, payload: string, context: dom.FrameExecutionContext) {
-    const { name, seq, serializedArgs } = JSON.parse(payload) as BindingPayload;
-    try {
-      assert(context.world);
-      const binding = page.getBinding(name);
-      if (!binding)
-        throw new Error(`Function "${name}" is not exposed`);
-      let result: any;
-      if (binding.needsHandle) {
-        const handle = await context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].takeBindingHandle(arg)`, { isFunction: true }, { name, seq }).catch(e => null);
-        result = await binding.playwrightFunction({ frame: context.frame, page, context: page.browserContext }, handle);
-      } else {
-        if (!Array.isArray(serializedArgs))
-          throw new Error(`serializedArgs is not an array. This can happen when Array.prototype.toJSON is defined incorrectly`);
-        const args = serializedArgs!.map(a => parseEvaluationResultValue(a));
-        result = await binding.playwrightFunction({ frame: context.frame, page, context: page.browserContext }, ...args);
-      }
-      context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].deliverBindingResult(arg)`, { isFunction: true }, { name, seq, result }).catch(e => debugLogger.log('error', e));
-    } catch (error) {
-      context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].deliverBindingResult(arg)`, { isFunction: true }, { name, seq, error }).catch(e => debugLogger.log('error', e));
-    }
-  }
+				const deliver = async (deliverPayload: any) => {
+					let deliveryError: any;
+					try {
+						await context.evaluate(deliverBindingResult, deliverPayload);
+						return;
+					} catch (e) {
+						deliveryError = e;
+					}
+					const frame = context.frame;
+					if (!frame) {
+						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(deliverBindingResult, deliverPayload);
+							return;
+						} catch {
+						}
+					}
+					debugLogger.log('error', deliveryError);
+				};
 
-  override async dispose(): Promise<void> {
-    await this.parent.removeExposedBinding(this);
-  }
-}
+				try {
+					assert(context.world);
+					const binding = page.getBinding(name);
+					if (!binding)
+						throw new Error(`Function "${name}" is not exposed`);
+
+					let result: any;
+					if (binding.needsHandle) {
+						const handle = await context.evaluateHandle(takeBindingHandle, { name, seq }).catch(e => null);
+						result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, handle);
+					} else {
+						if (!Array.isArray(serializedArgs))
+							throw new Error(`serializedArgs is not an array. This can happen when Array.prototype.toJSON is defined incorrectly`);
+						const args = serializedArgs!.map(a => parseEvaluationResultValue(a));
+						result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, ...args);
+					}
+					await deliver({ name, seq, result });
+				} catch (error) {
+					await deliver({ name, seq, error });
+				}
+			}
+
+			override async dispose(): Promise<void> {
+				await this.parent.removeExposedBinding(this);
+			}
+		}
+	
 
 export class InitScript extends DisposableObject {
   readonly source: string;
 
   constructor(owner: BrowserContext | Page, source: string) {
     super(owner);
-    this.source = `(() => {
-      ${source}
-    })();`;
+    this.source = `(() => { ${source} })();`;
   }
 
   async dispose() {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/pageBinding.ts patchright/packages/playwright-core/src/server/pageBinding.ts
---
+++
@@ -0,0 +1,91 @@
+;
+		/**
+		 * Copyright (c) Microsoft Corporation.
+		 *
+		 * Licensed under the Apache License, Version 2.0 (the "License");
+		 * you may not use this file except in compliance with the License.
+		 * You may obtain a copy of the License at
+		 *
+		 * http://www.apache.org/licenses/LICENSE-2.0
+		 *
+		 * Unless required by applicable law or agreed to in writing, software
+		 * distributed under the License is distributed on an "AS IS" BASIS,
+		 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+		 * See the License for the specific language governing permissions and
+		 * limitations under the License.
+		 */
+		import { source } from '../utils/isomorphic/oldUtilityScriptSerializers';
+
+		import type { SerializedValue } from '../utils/isomorphic/oldUtilityScriptSerializers';
+
+		export type BindingPayload = {
+			name: string;
+			seq: number;
+			serializedArgs?: SerializedValue[],
+		};
+
+		function addPageBinding(bindingName: string, needsHandle: boolean, utilityScriptSerializersFactory: typeof source) {
+			const { serializeAsCallArgument } = utilityScriptSerializersFactory;
+			// eslint-disable-next-line no-restricted-globals
+			const binding = (globalThis as any)[bindingName];
+			if (!binding || binding.toString().startsWith("(...args) => {")) return
+			// eslint-disable-next-line no-restricted-globals
+			(globalThis as any)[bindingName] = (...args: any[]) => {
+			// eslint-disable-next-line no-restricted-globals
+				const me = (globalThis as any)[bindingName];
+				if (needsHandle && args.slice(1).some(arg => arg !== undefined))
+					throw new Error(`exposeBindingHandle supports a single argument, ${args.length} received`);
+				let callbacks = me['callbacks'];
+				if (!callbacks) {
+					callbacks = new Map();
+					me['callbacks'] = callbacks;
+				}
+				const seq: number = (me['lastSeq'] || 0) + 1;
+				me['lastSeq'] = seq;
+				let handles = me['handles'];
+				if (!handles) {
+					handles = new Map();
+					me['handles'] = handles;
+				}
+				const promise = new Promise((resolve, reject) => callbacks.set(seq, { resolve, reject }));
+				let payload: BindingPayload;
+				if (needsHandle) {
+					handles.set(seq, args[0]);
+					payload = { name: bindingName, seq };
+				} else {
+					const serializedArgs = [];
+					for (let i = 0; i < args.length; i++) {
+						serializedArgs[i] = serializeAsCallArgument(args[i], v => {
+							return { fallThrough: v };
+						});
+					}
+					payload = { name: bindingName, seq, serializedArgs };
+				}
+				binding(JSON.stringify(payload));
+				return promise;
+			};
+			// eslint-disable-next-line no-restricted-globals
+		}
+
+		export function takeBindingHandle(arg: { name: string, seq: number }) {
+			// eslint-disable-next-line no-restricted-globals
+			const handles = (globalThis as any)[arg.name]['handles'];
+			const handle = handles.get(arg.seq);
+			handles.delete(arg.seq);
+			return handle;
+		}
+
+		export function deliverBindingResult(arg: { name: string, seq: number, result?: any, error?: any }) {
+			// eslint-disable-next-line no-restricted-globals
+			const callbacks = (globalThis as any)[arg.name]['callbacks'];
+			if ('error' in arg)
+				callbacks.get(arg.seq).reject(arg.error);
+			else
+				callbacks.get(arg.seq).resolve(arg.result);
+			callbacks.delete(arg.seq);
+		}
+
+		export function createPageBindingScript(name: string, needsHandle: boolean) {
+			return `(${addPageBinding.toString()})(${JSON.stringify(name)}, ${needsHandle}, (${source})())`;
+		}
+	
\ No newline at end of file
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/registry/index.ts patchright/packages/playwright-core/src/server/registry/index.ts
---
+++
@@ -1,20 +1,3 @@
-/**
- * Copyright 2017 Google Inc. All rights reserved.
- * Modifications copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
@@ -600,7 +583,7 @@
             `-  current: ${currentDockerVersion.dockerImageName}`,
             `- required: ${preferredDockerVersion.dockerImageName}`,
             ``,
-            `<3 Playwright Team`,
+            `<3 Patchright Team`,
           ].join('\n');
         } else if (isFfmpeg) {
           prettyMessage = [
@@ -610,7 +593,7 @@
             ``,
             `    ${buildPlaywrightCLICommand(sdkLanguage, 'install ffmpeg')}`,
             ``,
-            `<3 Playwright Team`,
+            `<3 Patchright Team`,
           ].join('\n');
         } else {
           prettyMessage = [
@@ -619,7 +602,7 @@
             ``,
             `    ${installCommand}`,
             ``,
-            `<3 Playwright Team`,
+            `<3 Patchright Team`,
           ].join('\n');
         }
         throw new Error(`Executable doesn't exist at ${e}\n${wrapInASCIIBox(prettyMessage, 1)}`);
@@ -1083,7 +1066,7 @@
       // Install browsers for this package.
       for (const executable of executables) {
         if (!executable._install)
-          throw new Error(`ERROR: Playwright does not support installing ${executable.name}`);
+          throw new Error(`ERROR: Patchright does not support installing ${executable.name}`);
 
         if (!getAsBooleanFromENV('CI') && !executable._isHermeticInstallation && !options?.force && executable.executablePath()) {
           const { embedderName } = getEmbedderName();
@@ -1102,7 +1085,7 @@
             ``,
             `    ${command}`,
             ``,
-            `<3 Playwright Team`,
+            `<3 Patchright Team`,
           ].join('\n'), 1) + '\n\n');
           return;
         }
@@ -1117,12 +1100,12 @@
           `  ${lockfilePath}`,
           ``,
           `Either:`,
-          `- wait a few minutes if other Playwright is installing browsers in parallel`,
+          `- wait a few minutes if other Patchright is installing browsers in parallel`,
           `- remove lock manually with:`,
           ``,
           `    ${rmCommand} ${lockfilePath}`,
           ``,
-          `<3 Playwright Team`,
+          `<3 Patchright Team`,
         ].join('\n'), 1));
       } else {
         throw e;
@@ -1217,13 +1200,13 @@
   private async _downloadExecutable(descriptor: BrowsersJSONDescriptor, force: boolean, executablePath?: string) {
     const downloadURLs = this._downloadURLs(descriptor);
     if (!downloadURLs.length)
-      throw new Error(`ERROR: Playwright does not support ${descriptor.name} on ${hostPlatform}`);
+      throw new Error(`ERROR: Patchright does not support ${descriptor.name} on ${hostPlatform}`);
     if (!isOfficiallySupportedPlatform)
-      logPolitely(`BEWARE: your OS is not officially supported by Playwright; downloading fallback build for ${hostPlatform}.`);
+      logPolitely(`BEWARE: your OS is not officially supported by Patchright; downloading fallback build for ${hostPlatform}.`);
     if (descriptor.hasRevisionOverride) {
       const message = `You are using a frozen ${descriptor.name} browser which does not receive updates anymore on ${hostPlatform}. Please update to the latest version of your operating system to test up-to-date browsers.`;
       if (process.env.GITHUB_ACTIONS)
-        console.log(`::warning title=Playwright::${message}`);  // eslint-disable-line no-console
+        console.log(`::warning title=Patchright::${message}`);  // eslint-disable-line no-console
       else
         logPolitely(message);
     }
@@ -1444,7 +1427,7 @@
 export function buildPlaywrightCLICommand(sdkLanguage: string, parameters: string): string {
   switch (sdkLanguage) {
     case 'python':
-      return `playwright ${parameters}`;
+      return `patchright ${parameters}`;
     case 'java':
       return `mvn exec:java -e -D exec.mainClass=com.microsoft.playwright.CLI -D exec.args="${parameters}"`;
     case 'csharp':
@@ -1497,7 +1480,7 @@
       ``,
       `    ${installCommand}`,
       ``,
-      `<3 Playwright Team`,
+      `<3 Patchright Team`,
     ].join('\n');
     throw new Error('\n' + wrapInASCIIBox(prettyMessage, 1));
   }
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/screenshotter.ts patchright/packages/playwright-core/src/server/screenshotter.ts
---
+++
@@ -254,6 +254,11 @@
     if (disableAnimations)
       progress.log('  disabled all CSS animations');
     const syncAnimations = this._page.delegate.shouldToggleStyleSheetToSyncAnimations();
+
+    			await Promise.all(this._page.frames().map(async (f: any) => {
+    				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) {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/trace/recorder/snapshotter.ts patchright/packages/playwright-core/src/server/trace/recorder/snapshotter.ts
---
+++
@@ -26,7 +26,6 @@
 import type { SnapshotData } from './snapshotterInjected';
 import type { RegisteredListener } from '../../utils/eventsHelper';
 import type { Frame } from '../../frames';
-import type { InitScript } from '../../page';
 import type { FrameSnapshot } from '@trace/snapshot';
 
 export type SnapshotterBlob = {
@@ -44,7 +43,7 @@
   private _delegate: SnapshotterDelegate;
   private _eventListeners: RegisteredListener[] = [];
   private _snapshotStreamer: string;
-  private _initScript: InitScript | undefined;
+  private _initScript: boolean | undefined;
   private _started = false;
 
   constructor(context: BrowserContext, delegate: SnapshotterDelegate) {
@@ -67,7 +66,7 @@
 
   async reset() {
     if (this._started)
-      await this._context.safeNonStallingEvaluateInAllFrames(`window["${this._snapshotStreamer}"].reset()`, 'main');
+      await this._context.safeNonStallingEvaluateInAllFrames(`window["${this._snapshotStreamer}"].reset()`, 'utility');
   }
 
   stop() {
@@ -75,25 +74,27 @@
   }
 
   async resetForReuse() {
-    // Next time we start recording, we will call addInitScript again.
-    if (this._initScript) {
-      eventsHelper.removeEventListeners(this._eventListeners);
-      await this._initScript.dispose();
-      this._initScript = undefined;
-    }
+
+    		if (this._initScript) {
+    			eventsHelper.removeEventListeners(this._eventListeners);
+    			this._initScript = undefined;
+    			this._initScriptSource = undefined;
+    		}
+    	
   }
 
   async _initialize() {
-    for (const page of this._context.pages())
-      this._onPage(page);
-    this._eventListeners = [
-      eventsHelper.addEventListener(this._context, BrowserContext.Events.Page, this._onPage.bind(this)),
-    ];
 
-    const { javaScriptEnabled } = this._context._options;
-    const initScriptSource = `(${frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === undefined})`;
-    this._initScript = await this._context.addInitScript(initScriptSource);
-    await this._context.safeNonStallingEvaluateInAllFrames(initScriptSource, 'main');
+    		const { javaScriptEnabled } = this._context._options;
+    		this._initScriptSource = `(${frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === undefined})`;
+    		this._initScript = true;
+    		for (const page of this._context.pages())
+    			this._onPage(page);
+    		this._eventListeners = [
+    			eventsHelper.addEventListener(this._context, BrowserContext.Events.Page, this._onPage.bind(this)),
+    		];
+    		await this._context.safeNonStallingEvaluateInAllFrames(this._initScriptSource, 'utility');
+    	
   }
 
   dispose() {
@@ -106,7 +107,7 @@
     (frame as any)[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) {
       // If we fail to capture snapshot in this frame, we cannot rely on the snapshot index
       // being the same here and in snapshotter injected script.
@@ -159,6 +160,7 @@
     for (const frame of page.frames())
       this._annotateFrameHierarchy(frame);
     this._eventListeners.push(eventsHelper.addEventListener(page, Page.Events.FrameAttached, frame => this._annotateFrameHierarchy(frame)));
+    this._eventListeners.push(eventsHelper.addEventListener(page, Page.Events.InternalFrameNavigatedToNewDocument, (frame: Frame) => this._onFrameNavigated(frame)));
   }
 
   private async _annotateFrameHierarchy(frame: Frame) {
@@ -167,7 +169,7 @@
       const parent = frame.parentFrame();
       if (!parent)
         return;
-      const context = await parent._mainContext();
+      const context = await parent._utilityContext();
       await context?.evaluate(({ snapshotStreamer, frameElement, frameId }) => {
         (window as any)[snapshotStreamer].markIframe(frameElement, frameId);
       }, { snapshotStreamer: this._snapshotStreamer, frameElement, frameId: frame.guid });
@@ -175,6 +177,18 @@
     } catch (e) {
     }
   }
+
+  _initScriptSource: string | undefined;
+
+  async _onFrameNavigated(frame: Frame) {
+
+    		if (!this._initScriptSource)
+    			return;
+    		try {
+    			await frame.nonStallingEvaluateInExistingContext(this._initScriptSource, 'utility');
+    		} catch (e) {}
+    	
+  }
 }
 
 const kNeedsResetSymbol = Symbol('kNeedsReset');
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/trace/recorder/snapshotterInjected.ts patchright/packages/playwright-core/src/server/trace/recorder/snapshotterInjected.ts
---
+++
@@ -85,33 +85,15 @@
 
   class Streamer {
     private _lastSnapshotNumber = 0;
-    private _staleStyleSheets = new Set<CSSStyleSheet>();
     private _modifiedStyleSheets = new Set<CSSStyleSheet>();
-    private _readingStyleSheet = false;  // To avoid invalidating due to our own reads.
     private _fakeBase: HTMLBaseElement;
     private _observer: MutationObserver;
 
     constructor() {
-      const invalidateCSSGroupingRule = (rule: CSSGroupingRule) => {
-        if (rule.parentStyleSheet)
-          this._invalidateStyleSheet(rule.parentStyleSheet);
-      };
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, 'insertRule', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, 'deleteRule', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, 'addRule', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, 'removeRule', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeGetter(window.CSSStyleSheet.prototype, 'rules', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeGetter(window.CSSStyleSheet.prototype, 'cssRules', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, 'replaceSync', (sheet: CSSStyleSheet) => 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: StyleSheet) => {
         if (sheet instanceof CSSStyleSheet)
           this._invalidateStyleSheet(sheet as CSSStyleSheet);
       });
-      this._interceptNativeAsyncMethod(window.CSSStyleSheet.prototype, 'replace', (sheet: CSSStyleSheet) => this._invalidateStyleSheet(sheet));
-
       this._fakeBase = document.createElement('base');
 
       this._observer = new MutationObserver(list => this._handleMutations(list));
@@ -162,40 +144,6 @@
       });
     }
 
-    private _interceptNativeMethod(obj: any, method: string, cb: (thisObj: any, result: any) => void) {
-      const native = obj[method] as Function;
-      if (!native)
-        return;
-      obj[method] = function(...args: any[]) {
-        const result = native.call(this, ...args);
-        cb(this, result);
-        return result;
-      };
-    }
-
-    private _interceptNativeAsyncMethod(obj: any, method: string, cb: (thisObj: any, result: any) => void) {
-      const native = obj[method] as Function;
-      if (!native)
-        return;
-      obj[method] = async function(...args: any[]) {
-        const result = await native.call(this, ...args);
-        cb(this, result);
-        return result;
-      };
-    }
-
-    private _interceptNativeGetter(obj: any, prop: string, cb: (thisObj: any, result: any) => void) {
-      const descriptor = Object.getOwnPropertyDescriptor(obj, prop)!;
-      Object.defineProperty(obj, prop, {
-        ...descriptor,
-        get: function() {
-          const result = descriptor.get!.call(this);
-          cb(this, result);
-          return result;
-        },
-      });
-    }
-
     private _interceptNativeSetter(obj: any, prop: string, cb: (thisObj: any, result: any) => void) {
       const descriptor = Object.getOwnPropertyDescriptor(obj, prop)!;
       Object.defineProperty(obj, prop, {
@@ -213,42 +161,37 @@
         ensureCachedData(mutation.target).attributesCached = undefined;
     }
 
-    private _invalidateStyleSheet(sheet: CSSStyleSheet) {
-      if (this._readingStyleSheet)
-        return;
-      this._staleStyleSheets.add(sheet);
-      if (sheet.href !== null)
-        this._modifiedStyleSheets.add(sheet);
-    }
-
     private _updateStyleElementStyleSheetTextIfNeeded(sheet: CSSStyleSheet, forceText?: boolean): string | undefined {
-      const data = ensureCachedData(sheet);
-      if (this._staleStyleSheets.has(sheet) || (forceText && data.cssText === undefined)) {
-        this._staleStyleSheets.delete(sheet);
-        try {
-          data.cssText = this._getSheetText(sheet);
-        } catch (e) {
-          // Sometimes we cannot access cross-origin stylesheets.
-          data.cssText = '';
-        }
-      }
-      return data.cssText;
+
+      		const data = ensureCachedData(sheet);
+      		try {
+      			data.cssText = this._getSheetText(sheet);
+      		} catch (e) {
+      			data.cssText = '';
+      		}
+      		return data.cssText;
+      	
     }
 
     // Returns either content, ref, or no override.
     private _updateLinkStyleSheetTextIfNeeded(sheet: CSSStyleSheet, snapshotNumber: number): string | number | undefined {
-      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) {
-          // Sometimes we cannot access cross-origin stylesheets.
-        }
-      }
-      return data.cssRef === undefined ? undefined : snapshotNumber - data.cssRef;
+
+      		const data = ensureCachedData(sheet);
+      		try {
+      			const currentText = this._getSheetText(sheet);
+      			if (data.cssText === undefined) {
+      				data.cssText = currentText;
+      				return undefined;
+      			}
+      			if (currentText === data.cssText)
+      				return data.cssRef === undefined ? undefined : snapshotNumber - data.cssRef;
+      			data.cssText = currentText;
+      			data.cssRef = snapshotNumber;
+      			return data.cssText;
+      		} catch (e) {
+      			return undefined;
+      		}
+      	
     }
 
     markIframe(iframeElement: HTMLIFrameElement | HTMLFrameElement, frameId: string) {
@@ -256,8 +199,6 @@
     }
 
     reset() {
-      this._staleStyleSheets.clear();
-
       const visitNode = (node: Node | ShadowRoot) => {
         resetCachedData(node);
         if (node.nodeType === Node.ELEMENT_NODE) {
@@ -326,17 +267,12 @@
     }
 
     private _getSheetText(sheet: CSSStyleSheet): string {
-      this._readingStyleSheet = true;
-      try {
-        if (sheet.disabled)
-          return '';
-        const rules: string[] = [];
-        for (const rule of sheet.cssRules)
-          rules.push(rule.cssText);
-        return rules.join('\n');
-      } finally {
-        this._readingStyleSheet = false;
-      }
+
+      		const rules: string[] = [];
+      		for (const rule of sheet.cssRules)
+      			rules.push(rule.cssText);
+      		return rules.join('\n');
+      	
     }
 
     captureSnapshot(needsReset: boolean): SnapshotData | undefined {
@@ -635,18 +571,18 @@
         collectionTime: 0,
       };
 
-      for (const sheet of this._modifiedStyleSheets) {
-        if (sheet.href === null)
-          continue;
-        const content = this._updateLinkStyleSheetTextIfNeeded(sheet, snapshotNumber);
-        if (content === undefined) {
-          // Unable to capture stylesheet contents.
-          continue;
-        }
-        const base = this._getSheetBase(sheet);
-        const url = removeHash(this._resolveUrl(base, sheet.href!));
-        result.resourceOverrides.push({ url, content, contentType: 'text/css' },);
-      }
+      for (const sheet of document.styleSheets) {
+              if (sheet.href === null)
+                continue;
+              const content = this._updateLinkStyleSheetTextIfNeeded(sheet, snapshotNumber);
+              if (content === undefined) {
+                // Unable to capture stylesheet contents.
+                continue;
+              }
+              const base = this._getSheetBase(sheet);
+              const url = removeHash(this._resolveUrl(base, sheet.href!));
+              result.resourceOverrides.push({ url, content, contentType: 'text/css' },);
+            }
 
       result.collectionTime = performance.now() - timestamp;
       return result;
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/trace/recorder/tracing.ts patchright/packages/playwright-core/src/server/trace/recorder/tracing.ts
---
+++
@@ -670,6 +670,11 @@
 }
 
 function createBeforeActionTraceEvent(metadata: CallMetadata, parentId?: string): trace.BeforeActionTraceEvent | null {
+
+  				// Filter out internal fallback Route.continue calls from Patchright's inject routing
+  				if (metadata.type === 'Route' && metadata.method === 'continue' && metadata.params?.isFallback)
+  					return null;
+  			
   if (metadata.internal || metadata.method.startsWith('tracing'))
     return null;
   const event: trace.BeforeActionTraceEvent = {
@@ -689,6 +694,11 @@
 }
 
 function createInputActionTraceEvent(metadata: CallMetadata): trace.InputActionTraceEvent | null {
+
+  				// Filter out internal fallback Route.continue calls from Patchright's inject routing
+  				if (metadata.type === 'Route' && metadata.method === 'continue' && metadata.params?.isFallback)
+  					return null;
+  			
   if (metadata.internal || metadata.method.startsWith('tracing'))
     return null;
   return {
@@ -699,6 +709,11 @@
 }
 
 function createActionLogTraceEvent(metadata: CallMetadata, message: string): trace.LogTraceEvent | null {
+
+  				// Filter out internal fallback Route.continue calls from Patchright's inject routing
+  				if (metadata.type === 'Route' && metadata.method === 'continue' && metadata.params?.isFallback)
+  					return null;
+  			
   if (metadata.internal || metadata.method.startsWith('tracing'))
     return null;
   return {
@@ -710,6 +725,11 @@
 }
 
 function createAfterActionTraceEvent(metadata: CallMetadata): trace.AfterActionTraceEvent | null {
+
+  				// Filter out internal fallback Route.continue calls from Patchright's inject routing
+  				if (metadata.type === 'Route' && metadata.method === 'continue' && metadata.params?.isFallback)
+  					return null;
+  			
   if (metadata.internal || metadata.method.startsWith('tracing'))
     return null;
   return {
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/server/utils/expectUtils.ts patchright/packages/playwright-core/src/server/utils/expectUtils.ts
---
+++
@@ -116,8 +116,7 @@
     details.printedDiff = undefined;
   }
 
-  const align = !details.errorMessage && details.printedExpected?.startsWith('Expected:')
-      && (!details.printedReceived || details.printedReceived.startsWith('Received:'));
+  const align = !details.errorMessage && details.printedExpected?.startsWith('Expected:') && (!details.printedReceived || details.printedReceived.startsWith('Received:'));
   if (details.locator)
     message += `Locator: ${align ? ' ' : ''}${details.locator}\n`;
   if (details.printedExpected)
diff -ruN -x protocol.yml --minimal playwright/packages/playwright-core/src/utils/isomorphic/oldUtilityScriptSerializers.ts patchright/packages/playwright-core/src/utils/isomorphic/oldUtilityScriptSerializers.ts
---
+++
@@ -0,0 +1,292 @@
+;
+		/**
+		 * Copyright (c) Microsoft Corporation.
+		 *
+		 * Licensed under the Apache License, Version 2.0 (the "License");
+		 * you may not use this file except in compliance with the License.
+		 * You may obtain a copy of the License at
+		 *
+		 * http://www.apache.org/licenses/LICENSE-2.0
+		 *
+		 * Unless required by applicable law or agreed to in writing, software
+		 * distributed under the License is distributed on an "AS IS" BASIS,
+		 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+		 * See the License for the specific language governing permissions and
+		 * limitations under the License.
+		 */
+
+		type TypedArrayKind = 'i8' | 'ui8' | 'ui8c' | 'i16' | 'ui16' | 'i32' | 'ui32' | 'f32' | 'f64' | 'bi64' | 'bui64';
+
+		export type SerializedValue =
+				undefined | boolean | number | string |
+				{ v: 'null' | 'undefined' | 'NaN' | 'Infinity' | '-Infinity' | '-0' } |
+				{ d: string } |
+				{ u: string } |
+				{ bi: string } |
+				{ e: { n: string, m: string, s: string } } |
+				{ r: { p: string, f: string } } |
+				{ a: SerializedValue[], id: number } |
+				{ o: { k: string, v: SerializedValue }[], id: number } |
+				{ ref: number } |
+				{ h: number } |
+				{ ta: { b: string, k: TypedArrayKind } };
+
+		type HandleOrValue = { h: number } | { fallThrough: any };
+
+		type VisitorInfo = {
+			visited: Map<object, number>;
+			lastId: number;
+		};
+
+		export function source() {
+
+			function isRegExp(obj: any): obj is RegExp {
+				try {
+					return obj instanceof RegExp || Object.prototype.toString.call(obj) === '[object RegExp]';
+				} catch (error) {
+					return false;
+				}
+			}
+
+			function isDate(obj: any): obj is Date {
+				try {
+					return obj instanceof Date || Object.prototype.toString.call(obj) === '[object Date]';
+				} catch (error) {
+					return false;
+				}
+			}
+
+			function isURL(obj: any): obj is URL {
+				try {
+					return obj instanceof URL || Object.prototype.toString.call(obj) === '[object URL]';
+				} catch (error) {
+					return false;
+				}
+			}
+
+			function isError(obj: any): obj is Error {
+				try {
+					return obj instanceof Error || (obj && Object.getPrototypeOf(obj)?.name === 'Error');
+				} catch (error) {
+					return false;
+				}
+			}
+
+			function isTypedArray(obj: any, constructor: Function): boolean {
+				try {
+					return obj instanceof constructor || Object.prototype.toString.call(obj) === `[object ${constructor.name}]`;
+				} catch (error) {
+					return false;
+				}
+			}
+
+			const typedArrayConstructors: Record<TypedArrayKind, Function> = {
+				i8: Int8Array,
+				ui8: Uint8Array,
+				ui8c: Uint8ClampedArray,
+				i16: Int16Array,
+				ui16: Uint16Array,
+				i32: Int32Array,
+				ui32: Uint32Array,
+				// TODO: add Float16Array once it's in baseline
+				f32: Float32Array,
+				f64: Float64Array,
+				bi64: BigInt64Array,
+				bui64: BigUint64Array,
+			};
+
+			function typedArrayToBase64(array: any) {
+				/**
+				 * Firefox does not support iterating over typed arrays, so we use `.toBase64`.
+				 * Error: 'Accessing TypedArray data over Xrays is slow, and forbidden in order to encourage performant code. To copy TypedArrays across origin boundaries, consider using Components.utils.cloneInto().'
+				 */
+				if ('toBase64' in array)
+					return array.toBase64();
+				const binary = Array.from(new Uint8Array(array.buffer, array.byteOffset, array.byteLength)).map(b => String.fromCharCode(b)).join('');
+				return btoa(binary);
+			}
+
+			function base64ToTypedArray(base64: string, TypedArrayConstructor: any) {
+				const binary = atob(base64);
+				const bytes = new Uint8Array(binary.length);
+				for (let i = 0; i < binary.length; i++)
+					bytes[i] = binary.charCodeAt(i);
+				return new TypedArrayConstructor(bytes.buffer);
+			}
+
+			function parseEvaluationResultValue(value: SerializedValue, handles: any[] = [], refs: Map<number, object> = new Map()): any {
+				if (Object.is(value, undefined))
+					return undefined;
+				if (typeof value === 'object' && value) {
+					if ('ref' in value)
+						return refs.get(value.ref);
+					if ('v' in value) {
+						if (value.v === 'undefined')
+							return undefined;
+						if (value.v === 'null')
+							return null;
+						if (value.v === 'NaN')
+							return NaN;
+						if (value.v === 'Infinity')
+							return Infinity;
+						if (value.v === '-Infinity')
+							return -Infinity;
+						if (value.v === '-0')
+							return -0;
+						return undefined;
+					}
+					if ('d' in value)
+						return new Date(value.d);
+					if ('u' in value)
+						return new URL(value.u);
+					if ('bi' in value)
+						return BigInt(value.bi);
+					if ('e' in value) {
+						const error = new Error(value.e.m);
+						error.name = value.e.n;
+						error.stack = value.e.s;
+						return error;
+					}
+					if ('r' in value)
+						return new RegExp(value.r.p, value.r.f);
+					if ('a' in value) {
+						const result: any[] = [];
+						refs.set(value.id, result);
+						for (const a of value.a)
+							result.push(parseEvaluationResultValue(a, handles, refs));
+						return result;
+					}
+					if ('o' in value) {
+						const result: any = {};
+						refs.set(value.id, result);
+						for (const { k, v } of value.o)
+							result[k] = parseEvaluationResultValue(v, handles, refs);
+						return result;
+					}
+					if ('h' in value)
+						return handles[value.h];
+					if ('ta' in value)
+						return base64ToTypedArray(value.ta.b, typedArrayConstructors[value.ta.k]);
+				}
+				return value;
+			}
+
+			function serializeAsCallArgument(value: any, handleSerializer: (value: any) => HandleOrValue): SerializedValue {
+				return serialize(value, handleSerializer, { visited: new Map(), lastId: 0 });
+			}
+
+			function serialize(value: any, handleSerializer: (value: any) => HandleOrValue, visitorInfo: VisitorInfo): SerializedValue {
+				if (value && typeof value === 'object') {
+					// eslint-disable-next-line no-restricted-globals
+					if (typeof globalThis.Window === 'function' && value instanceof globalThis.Window)
+						return 'ref: <Window>';
+					// eslint-disable-next-line no-restricted-globals
+					if (typeof globalThis.Document === 'function' && value instanceof globalThis.Document)
+						return 'ref: <Document>';
+					// eslint-disable-next-line no-restricted-globals
+					if (typeof globalThis.Node === 'function' && value instanceof globalThis.Node)
+						return 'ref: <Node>';
+				}
+				return innerSerialize(value, handleSerializer, visitorInfo);
+			}
+
+			function innerSerialize(value: any, handleSerializer: (value: any) => HandleOrValue, visitorInfo: VisitorInfo): SerializedValue {
+				const result = handleSerializer(value);
+				if ('fallThrough' in result)
+					value = result.fallThrough;
+				else
+					return result;
+
+				if (typeof value === 'symbol')
+					return { v: 'undefined' };
+				if (Object.is(value, undefined))
+					return { v: 'undefined' };
+				if (Object.is(value, null))
+					return { v: 'null' };
+				if (Object.is(value, NaN))
+					return { v: 'NaN' };
+				if (Object.is(value, Infinity))
+					return { v: 'Infinity' };
+				if (Object.is(value, -Infinity))
+					return { v: '-Infinity' };
+				if (Object.is(value, -0))
+					return { v: '-0' };
+
+				if (typeof value === 'boolean')
+					return value;
+				if (typeof value === 'number')
+					return value;
+				if (typeof value === 'string')
+					return value;
+				if (typeof value === 'bigint')
+					return { bi: value.toString() };
+
+				if (isError(value)) {
+					let stack;
+					if (value.stack?.startsWith(value.name + ': ' + value.message)) {
+						// v8
+						stack = value.stack;
+					} else {
+						stack = `${value.name}: ${value.message}
+${value.stack}`;
+					}
+					return { e: { n: value.name, m: value.message, s: stack } };
+				}
+				if (isDate(value))
+					return { d: value.toJSON() };
+				if (isURL(value))
+					return { u: value.toJSON() };
+				if (isRegExp(value))
+					return { r: { p: value.source, f: value.flags } };
+				for (const [k, ctor] of Object.entries(typedArrayConstructors) as [TypedArrayKind, Function][]) {
+					if (isTypedArray(value, ctor))
+						return { ta: { b: typedArrayToBase64(value), k } };
+				}
+
+				const id = visitorInfo.visited.get(value);
+				if (id)
+					return { ref: id };
+
+				if (Array.isArray(value)) {
+					const a = [];
+					const id = ++visitorInfo.lastId;
+					visitorInfo.visited.set(value, id);
+					for (let i = 0; i < value.length; ++i)
+						a.push(serialize(value[i], handleSerializer, visitorInfo));
+					return { a, id };
+				}
+
+				if (typeof value === 'object') {
+					const o: { k: string, v: SerializedValue }[] = [];
+					const id = ++visitorInfo.lastId;
+					visitorInfo.visited.set(value, id);
+					for (const name of Object.keys(value)) {
+						let item;
+						try {
+							item = value[name];
+						} catch (e) {
+							continue;  // native bindings will throw sometimes;
+						}
+						if (name === 'toJSON' && typeof item === 'function')
+							o.push({ k: name, v: { o: [], id: 0 } });
+						else
+							o.push({ k: name, v: serialize(item, handleSerializer, visitorInfo) });
+					}
+
+					let jsonWrapper;
+					try {
+						// If Object.keys().length === 0 we fall back to toJSON if it exists
+						if (o.length === 0 && value.toJSON && typeof value.toJSON === 'function')
+							jsonWrapper = { value: value.toJSON() };
+					} catch (e) {
+					}
+					if (jsonWrapper)
+						return innerSerialize(jsonWrapper.value, handleSerializer, visitorInfo);
+
+					return { o, id };
+				}
+			}
+
+			return { parseEvaluationResultValue, serializeAsCallArgument };
+		}
+	
\ No newline at end of file
diff -ruN -x protocol.yml --minimal playwright/packages/recorder/src/recorder.tsx patchright/packages/recorder/src/recorder.tsx
---
+++
@@ -101,7 +101,7 @@
   }, [backend, mode, selectedTab, setSelectedTab, source]);
 
   React.useEffect(() => {
-    backend.setAutoExpect({ autoExpect });
+    try { window.dispatch({ event: 'setAutoExpect', params: { autoExpect } }); } catch {}		
   }, [autoExpect, backend]);
 
   React.useLayoutEffect(() => {