patchright-core 1.52.5 → 1.55.0

package/lib/server/android/android.js

@@ -36,7 +36,6 @@ var import_events = require("events");
 var import_fs = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
-var import_timeoutSettings = require("../timeoutSettings");
 var import_pipeTransport = require("../utils/pipeTransport");
 var import_crypto = require("../utils/crypto");
 var import_debug = require("../utils/debug");
@@ -60,20 +59,15 @@ class Android extends import_instrumentation.SdkObject {
     super(parent, "android");
     this._devices = /* @__PURE__ */ new Map();
     this._backend = backend;
-    this._timeoutSettings = new import_timeoutSettings.TimeoutSettings();
   }
-  setDefaultTimeout(timeout) {
-    this._timeoutSettings.setDefaultTimeout(timeout);
-  }
-  async devices(options) {
-    const devices = (await this._backend.devices(options)).filter((d) => d.status === "device");
+  async devices(progress, options) {
+    const devices = (await progress.race(this._backend.devices(options))).filter((d) => d.status === "device");
     const newSerials = /* @__PURE__ */ new Set();
     for (const d of devices) {
       newSerials.add(d.serial);
       if (this._devices.has(d.serial))
         continue;
-      const device = await AndroidDevice.create(this, d, options);
-      this._devices.set(d.serial, device);
+      await progress.race(AndroidDevice.create(this, d, options).then((device) => this._devices.set(d.serial, device)));
     }
     for (const d of this._devices.keys()) {
       if (!newSerials.has(d))
@@ -98,7 +92,7 @@ class AndroidDevice extends import_instrumentation.SdkObject {
     this.model = model;
     this.serial = backend.serial;
     this._options = options;
-    this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(android._timeoutSettings);
+    this.logName = "browser";
   }
   static {
     this.Events = {
@@ -124,16 +118,13 @@ class AndroidDevice extends import_instrumentation.SdkObject {
     };
     poll();
   }
-  setDefaultTimeout(timeout) {
-    this._timeoutSettings.setDefaultTimeout(timeout);
-  }
   async shell(command) {
     const result = await this._backend.runCommand(`shell:${command}`);
     await this._refreshWebViews();
     return result;
   }
-  async open(command) {
-    return await this._backend.open(`${command}`);
+  async open(progress, command) {
+    return await this._open(progress, command);
   }
   async screenshot() {
     return await this._backend.runCommand(`shell:screencap -p`);
@@ -141,17 +132,19 @@ class AndroidDevice extends import_instrumentation.SdkObject {
   async _driver() {
     if (this._isClosed)
       return;
-    if (!this._driverPromise)
-      this._driverPromise = this._installDriver();
+    if (!this._driverPromise) {
+      const controller = new import_progress.ProgressController();
+      this._driverPromise = controller.run((progress) => this._installDriver(progress));
+    }
     return this._driverPromise;
   }
-  async _installDriver() {
+  async _installDriver(progress) {
     (0, import_utilsBundle.debug)("pw:android")("Stopping the old driver");
-    await this.shell(`am force-stop com.microsoft.playwright.androiddriver`);
+    await progress.race(this.shell(`am force-stop com.microsoft.playwright.androiddriver`));
     if (!this._options.omitDriverInstall) {
       (0, import_utilsBundle.debug)("pw:android")("Uninstalling the old driver");
-      await this.shell(`cmd package uninstall com.microsoft.playwright.androiddriver`);
-      await this.shell(`cmd package uninstall com.microsoft.playwright.androiddriver.test`);
+      await progress.race(this.shell(`cmd package uninstall com.microsoft.playwright.androiddriver`));
+      await progress.race(this.shell(`cmd package uninstall com.microsoft.playwright.androiddriver.test`));
       (0, import_utilsBundle.debug)("pw:android")("Installing the new driver");
       const executable = import_registry.registry.findExecutable("android");
       const packageManagerCommand = (0, import_env.getPackageManagerExecCommand)();
@@ -159,14 +152,14 @@ class AndroidDevice extends import_instrumentation.SdkObject {
         const fullName = import_path.default.join(executable.directory, file);
         if (!import_fs.default.existsSync(fullName))
           throw new Error(`Please install Android driver apk using '${packageManagerCommand} playwright install android'`);
-        await this.installApk(await import_fs.default.promises.readFile(fullName));
+        await this.installApk(progress, await progress.race(import_fs.default.promises.readFile(fullName)));
       }
     } else {
       (0, import_utilsBundle.debug)("pw:android")("Skipping the driver installation");
     }
     (0, import_utilsBundle.debug)("pw:android")("Starting the new driver");
     this.shell("am instrument -w com.microsoft.playwright.androiddriver.test/androidx.test.runner.AndroidJUnitRunner").catch((e) => (0, import_utilsBundle.debug)("pw:android")(e));
-    const socket = await this._waitForLocalAbstract("playwright_android_driver_socket");
+    const socket = await this._waitForLocalAbstract(progress, "playwright_android_driver_socket");
     const transport = new import_pipeTransport.PipeTransport(socket, socket, socket, "be");
     transport.onmessage = (message) => {
       const response = JSON.parse(message);
@@ -182,21 +175,31 @@ class AndroidDevice extends import_instrumentation.SdkObject {
     };
     return transport;
   }
-  async _waitForLocalAbstract(socketName) {
+  async _waitForLocalAbstract(progress, socketName) {
     let socket;
     (0, import_utilsBundle.debug)("pw:android")(`Polling the socket localabstract:${socketName}`);
     while (!socket) {
       try {
-        socket = await this._backend.open(`localabstract:${socketName}`);
+        socket = await this._open(progress, `localabstract:${socketName}`);
       } catch (e) {
-        await new Promise((f) => setTimeout(f, 250));
+        if ((0, import_progress.isAbortError)(e))
+          throw e;
+        await progress.wait(250);
       }
     }
     (0, import_utilsBundle.debug)("pw:android")(`Connected to localabstract:${socketName}`);
     return socket;
   }
   async send(method, params = {}) {
-    params.timeout = this._timeoutSettings.timeout(params);
+    params = {
+      ...params,
+      // Patch the timeout in, just in case it's missing in one of the commands.
+      timeout: params.timeout || 0
+    };
+    if (params.androidSelector) {
+      params.selector = params.androidSelector;
+      delete params.androidSelector;
+    }
     const driver = await this._driver();
     if (!driver)
       throw new Error("Device is closed");
@@ -221,17 +224,23 @@ class AndroidDevice extends import_instrumentation.SdkObject {
     this._android._deviceClosed(this);
     this.emit(AndroidDevice.Events.Close);
   }
-  async launchBrowser(pkg = "com.android.chrome", options) {
+  async launchBrowser(progress, pkg = "com.android.chrome", options) {
     (0, import_utilsBundle.debug)("pw:android")("Force-stopping", pkg);
     await this._backend.runCommand(`shell:am force-stop ${pkg}`);
     const socketName = (0, import_debug.isUnderTest)() ? "webview_devtools_remote_playwright_test" : "playwright_" + (0, import_crypto.createGuid)() + "_devtools_remote";
     const commandLine = this._defaultArgs(options, socketName).join(" ");
     (0, import_utilsBundle.debug)("pw:android")("Starting", pkg, commandLine);
-    await this._backend.runCommand(`shell:echo "${Buffer.from(commandLine).toString("base64")}" | base64 -d > /data/local/tmp/chrome-command-line`);
-    await this._backend.runCommand(`shell:am start -a android.intent.action.VIEW -d about:blank ${pkg}`);
-    const browserContext = await this._connectToBrowser(socketName, options);
-    await this._backend.runCommand(`shell:rm /data/local/tmp/chrome-command-line`);
-    return browserContext;
+    await progress.race(this._backend.runCommand(`shell:echo "${Buffer.from(commandLine).toString("base64")}" | base64 -d > /data/local/tmp/chrome-command-line`));
+    await progress.race(this._backend.runCommand(`shell:am start -a android.intent.action.VIEW -d about:blank ${pkg}`));
+    const browserContext = await this._connectToBrowser(progress, socketName, options);
+    try {
+      await progress.race(this._backend.runCommand(`shell:rm /data/local/tmp/chrome-command-line`));
+      return browserContext;
+    } catch (error) {
+      await browserContext.close({ reason: "Failed to launch" }).catch(() => {
+      });
+      throw error;
+    }
   }
   _defaultArgs(options, socketName) {
     const chromeArguments = [
@@ -239,7 +248,7 @@ class AndroidDevice extends import_instrumentation.SdkObject {
       "--disable-fre",
       "--no-default-browser-check",
       `--remote-debugging-socket-name=${socketName}`,
-      ...import_chromiumSwitches.chromiumSwitches,
+      ...(0, import_chromiumSwitches.chromiumSwitches)(),
       ...this._innerDefaultArgs(options)
     ];
     return chromeArguments;
@@ -260,82 +269,87 @@ class AndroidDevice extends import_instrumentation.SdkObject {
     chromeArguments.push(...args);
     return chromeArguments;
   }
-  async connectToWebView(socketName) {
+  async connectToWebView(progress, socketName) {
     const webView = this._webViews.get(socketName);
     if (!webView)
       throw new Error("WebView has been closed");
-    return await this._connectToBrowser(socketName);
-  }
-  async _connectToBrowser(socketName, options = {}) {
-    const socket = await this._waitForLocalAbstract(socketName);
-    const androidBrowser = new AndroidBrowser(this, socket);
-    await androidBrowser._init();
-    this._browserConnections.add(androidBrowser);
-    const artifactsDir = await import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER);
-    const cleanupArtifactsDir = async () => {
-      const errors = (await (0, import_fileUtils.removeFolders)([artifactsDir])).filter(Boolean);
-      for (let i = 0; i < (errors || []).length; ++i)
-        (0, import_utilsBundle.debug)("pw:android")(`exception while removing ${artifactsDir}: ${errors[i]}`);
-    };
-    import_processLauncher.gracefullyCloseSet.add(cleanupArtifactsDir);
-    socket.on("close", async () => {
-      import_processLauncher.gracefullyCloseSet.delete(cleanupArtifactsDir);
-      cleanupArtifactsDir().catch((e) => (0, import_utilsBundle.debug)("pw:android")(`could not cleanup artifacts dir: ${e}`));
-    });
-    const browserOptions = {
-      name: "clank",
-      isChromium: true,
-      slowMo: 0,
-      persistent: { ...options, noDefaultViewport: true },
-      artifactsDir,
-      downloadsPath: artifactsDir,
-      tracesDir: artifactsDir,
-      browserProcess: new ClankBrowserProcess(androidBrowser),
-      proxy: options.proxy,
-      protocolLogger: import_helper.helper.debugProtocolLogger(),
-      browserLogsCollector: new import_debugLogger.RecentLogsCollector(),
-      originalLaunchOptions: {}
-    };
-    (0, import_browserContext.validateBrowserContextOptions)(options, browserOptions);
-    const browser = await import_crBrowser.CRBrowser.connect(this.attribution.playwright, androidBrowser, browserOptions);
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this);
-    const defaultContext = browser._defaultContext;
-    await controller.run(async (progress) => {
+    return await this._connectToBrowser(progress, socketName);
+  }
+  async _connectToBrowser(progress, socketName, options = {}) {
+    const socket = await this._waitForLocalAbstract(progress, socketName);
+    try {
+      const androidBrowser = new AndroidBrowser(this, socket);
+      await progress.race(androidBrowser._init());
+      this._browserConnections.add(androidBrowser);
+      const artifactsDir = await progress.race(import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER));
+      const cleanupArtifactsDir = async () => {
+        const errors = (await (0, import_fileUtils.removeFolders)([artifactsDir])).filter(Boolean);
+        for (let i = 0; i < (errors || []).length; ++i)
+          (0, import_utilsBundle.debug)("pw:android")(`exception while removing ${artifactsDir}: ${errors[i]}`);
+      };
+      import_processLauncher.gracefullyCloseSet.add(cleanupArtifactsDir);
+      socket.on("close", async () => {
+        import_processLauncher.gracefullyCloseSet.delete(cleanupArtifactsDir);
+        cleanupArtifactsDir().catch((e) => (0, import_utilsBundle.debug)("pw:android")(`could not cleanup artifacts dir: ${e}`));
+      });
+      const browserOptions = {
+        name: "clank",
+        isChromium: true,
+        slowMo: 0,
+        persistent: { ...options, noDefaultViewport: true },
+        artifactsDir,
+        downloadsPath: artifactsDir,
+        tracesDir: artifactsDir,
+        browserProcess: new ClankBrowserProcess(androidBrowser),
+        proxy: options.proxy,
+        protocolLogger: import_helper.helper.debugProtocolLogger(),
+        browserLogsCollector: new import_debugLogger.RecentLogsCollector(),
+        originalLaunchOptions: {}
+      };
+      (0, import_browserContext.validateBrowserContextOptions)(options, browserOptions);
+      const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, androidBrowser, browserOptions));
+      const defaultContext = browser._defaultContext;
       await defaultContext._loadDefaultContextAsIs(progress);
-    });
-    return defaultContext;
+      return defaultContext;
+    } catch (error) {
+      socket.close();
+      throw error;
+    }
+  }
+  _open(progress, command) {
+    return (0, import_progress.raceUncancellableOperationWithCleanup)(progress, () => this._backend.open(command), (socket) => socket.close());
   }
   webViews() {
     return [...this._webViews.values()];
   }
-  async installApk(content, options) {
+  async installApk(progress, content, options) {
     const args = options && options.args ? options.args : ["-r", "-t", "-S"];
     (0, import_utilsBundle.debug)("pw:android")("Opening install socket");
-    const installSocket = await this._backend.open(`shell:cmd package install ${args.join(" ")} ${content.length}`);
+    const installSocket = await this._open(progress, `shell:cmd package install ${args.join(" ")} ${content.length}`);
     (0, import_utilsBundle.debug)("pw:android")("Writing driver bytes: " + content.length);
-    await installSocket.write(content);
-    const success = await new Promise((f) => installSocket.on("data", f));
+    await progress.race(installSocket.write(content));
+    const success = await progress.race(new Promise((f) => installSocket.on("data", f)));
     (0, import_utilsBundle.debug)("pw:android")("Written driver bytes: " + success);
     installSocket.close();
   }
-  async push(content, path2, mode = 420) {
-    const socket = await this._backend.open(`sync:`);
+  async push(progress, content, path2, mode = 420) {
+    const socket = await this._open(progress, `sync:`);
     const sendHeader = async (command, length) => {
       const buffer = Buffer.alloc(command.length + 4);
       buffer.write(command, 0);
       buffer.writeUInt32LE(length, command.length);
-      await socket.write(buffer);
+      await progress.race(socket.write(buffer));
     };
     const send = async (command, data) => {
       await sendHeader(command, data.length);
-      await socket.write(data);
+      await progress.race(socket.write(data));
     };
     await send("SEND", Buffer.from(`${path2},${mode}`));
     const maxChunk = 65535;
     for (let i = 0; i < content.length; i += maxChunk)
       await send("DATA", content.slice(i, i + maxChunk));
     await sendHeader("DONE", Date.now() / 1e3 | 0);
-    const result = await new Promise((f) => socket.once("data", f));
+    const result = await progress.race(new Promise((f) => socket.once("data", f)));
     const code = result.slice(0, 4).toString();
     if (code !== "OKAY")
       throw new Error("Could not push: " + code);

package/lib/server/android/backendAdb.js

@@ -34,7 +34,6 @@ module.exports = __toCommonJS(backendAdb_exports);
 var import_events = require("events");
 var import_net = __toESM(require("net"));
 var import_assert = require("../../utils/isomorphic/assert");
-var import_crypto = require("../utils/crypto");
 var import_utilsBundle = require("../../utilsBundle");
 class AdbBackend {
   async devices(options = {}) {
@@ -116,7 +115,6 @@ function encodeMessage(message) {
 class BufferedSocketWrapper extends import_events.EventEmitter {
   constructor(command, socket) {
     super();
-    this.guid = (0, import_crypto.createGuid)();
     this._buffer = Buffer.from([]);
     this._isSocket = false;
     this._isClosed = false;

package/lib/server/bidi/bidiBrowser.js

@@ -40,6 +40,7 @@ var network = __toESM(require("../network"));
 var import_bidiConnection = require("./bidiConnection");
 var import_bidiNetworkManager = require("./bidiNetworkManager");
 var import_bidiPage = require("./bidiPage");
+var import_page = require("../page");
 var bidi = __toESM(require("./third_party/bidiProtocol"));
 class BidiBrowser extends import_browser.Browser {
   constructor(parent, transport, options) {
@@ -57,38 +58,11 @@ class BidiBrowser extends import_browser.Browser {
     const browser = new BidiBrowser(parent, transport, options);
     if (options.__testHookOnConnectToBrowser)
       await options.__testHookOnConnectToBrowser();
-    let proxy;
-    if (options.proxy) {
-      proxy = {
-        proxyType: "manual"
-      };
-      const url = new URL(options.proxy.server);
-      switch (url.protocol) {
-        case "http:":
-          proxy.httpProxy = url.host;
-          break;
-        case "https:":
-          proxy.httpsProxy = url.host;
-          break;
-        case "socks4:":
-          proxy.socksProxy = url.host;
-          proxy.socksVersion = 4;
-          break;
-        case "socks5:":
-          proxy.socksProxy = url.host;
-          proxy.socksVersion = 5;
-          break;
-        default:
-          throw new Error("Invalid proxy server protocol: " + options.proxy.server);
-      }
-      if (options.proxy.bypass)
-        proxy.noProxy = options.proxy.bypass.split(",");
-    }
     browser._bidiSessionInfo = await browser._browserSession.send("session.new", {
       capabilities: {
         alwaysMatch: {
-          acceptInsecureCerts: false,
-          proxy,
+          acceptInsecureCerts: options.persistent?.internalIgnoreHTTPSErrors || options.persistent?.ignoreHTTPSErrors,
+          proxy: getProxyConfiguration(options.originalLaunchOptions.proxyOverride ?? options.proxy),
           unhandledPromptBehavior: {
             default: bidi.Session.UserPromptHandlerType.Ignore
           },
@@ -117,7 +91,11 @@ class BidiBrowser extends import_browser.Browser {
     this._didClose();
   }
   async doCreateNewContext(options) {
-    const { userContext } = await this._browserSession.send("browser.createUserContext", {});
+    const proxy = options.proxyOverride || options.proxy;
+    const { userContext } = await this._browserSession.send("browser.createUserContext", {
+      acceptInsecureCerts: options.internalIgnoreHTTPSErrors || options.ignoreHTTPSErrors,
+      proxy: getProxyConfiguration(proxy)
+    });
     const context = new BidiBrowserContext(this, userContext, options);
     await context._initialize();
     this._contexts.set(userContext, context);
@@ -139,12 +117,12 @@ class BidiBrowser extends import_browser.Browser {
     if (event.parent) {
       const parentFrameId = event.parent;
       for (const page2 of this._bidiPages.values()) {
-        const parentFrame = page2._page._frameManager.frame(parentFrameId);
+        const parentFrame = page2._page.frameManager.frame(parentFrameId);
         if (!parentFrame)
           continue;
         page2._session.addFrameBrowsingContext(event.context);
-        page2._page._frameManager.frameAttached(event.context, parentFrameId);
-        const frame = page2._page._frameManager.frame(event.context);
+        page2._page.frameManager.frameAttached(event.context, parentFrameId);
+        const frame = page2._page.frameManager.frame(event.context);
         if (frame)
           frame._url = event.url;
         return;
@@ -167,10 +145,10 @@ class BidiBrowser extends import_browser.Browser {
       this._browserSession.removeFrameBrowsingContext(event.context);
       const parentFrameId = event.parent;
       for (const page of this._bidiPages.values()) {
-        const parentFrame = page._page._frameManager.frame(parentFrameId);
+        const parentFrame = page._page.frameManager.frame(parentFrameId);
         if (!parentFrame)
           continue;
-        page._page._frameManager.frameDetached(event.context);
+        page._page.frameManager.frameDetached(event.context);
         return;
       }
       return;
@@ -191,7 +169,8 @@ class BidiBrowser extends import_browser.Browser {
 class BidiBrowserContext extends import_browserContext.BrowserContext {
   constructor(browser, browserContextId, options) {
     super(browser, options, browserContextId);
-    this._initScriptIds = [];
+    this._originToPermissions = /* @__PURE__ */ new Map();
+    this._initScriptIds = /* @__PURE__ */ new Map();
     this._authenticateProxyViaHeader();
   }
   _bidiPages() {
@@ -199,42 +178,23 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
   }
   async _initialize() {
     const promises = [
-      super._initialize(),
-      this._installMainBinding()
+      super._initialize()
     ];
-    if (this._options.viewport) {
-      promises.push(this._browser._browserSession.send("browsingContext.setViewport", {
-        viewport: {
-          width: this._options.viewport.width,
-          height: this._options.viewport.height
-        },
-        devicePixelRatio: this._options.deviceScaleFactor || 1,
+    promises.push(this.doUpdateDefaultViewport());
+    if (this._options.geolocation)
+      promises.push(this.setGeolocation(this._options.geolocation));
+    if (this._options.locale) {
+      promises.push(this._browser._browserSession.send("emulation.setLocaleOverride", {
+        locale: this._options.locale,
         userContexts: [this._userContextId()]
       }));
     }
     await Promise.all(promises);
   }
-  // TODO: consider calling this only when bindings are added.
-  async _installMainBinding() {
-    const functionDeclaration = import_bidiPage.addMainBinding.toString();
-    const args = [{
-      type: "channel",
-      value: {
-        channel: import_bidiPage.kPlaywrightBindingChannel,
-        ownership: bidi.Script.ResultOwnership.Root
-      }
-    }];
-    await this._browser._browserSession.send("script.addPreloadScript", {
-      functionDeclaration,
-      arguments: args,
-      userContexts: [this._userContextId()]
-    });
-  }
   possiblyUninitializedPages() {
     return this._bidiPages().map((bidiPage) => bidiPage._page);
   }
   async doCreateNewPage() {
-    (0, import_browserContext.assertBrowserContextIsNotOwned)(this);
     const { context } = await this._browser._browserSession.send("browsingContext.create", {
       type: bidi.BrowsingContext.CreateType.Window,
       userContext: this._browserContextId
@@ -287,38 +247,114 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
     );
   }
   async doGrantPermissions(origin, permissions) {
+    const currentPermissions = this._originToPermissions.get(origin) || [];
+    const toGrant = permissions.filter((permission) => !currentPermissions.includes(permission));
+    this._originToPermissions.set(origin, [...currentPermissions, ...toGrant]);
+    await Promise.all(toGrant.map((permission) => this._setPermission(origin, permission, bidi.Permissions.PermissionState.Granted)));
   }
   async doClearPermissions() {
+    const currentPermissions = [...this._originToPermissions.entries()];
+    this._originToPermissions = /* @__PURE__ */ new Map();
+    await Promise.all(currentPermissions.map(([origin, permissions]) => permissions.map(
+      (p) => this._setPermission(origin, p, bidi.Permissions.PermissionState.Prompt)
+    )));
+  }
+  async _setPermission(origin, permission, state) {
+    await this._browser._browserSession.send("permissions.setPermission", {
+      descriptor: {
+        name: permission
+      },
+      state,
+      origin,
+      userContext: this._userContextId()
+    });
   }
   async setGeolocation(geolocation) {
+    (0, import_browserContext.verifyGeolocation)(geolocation);
+    this._options.geolocation = geolocation;
+    await this._browser._browserSession.send("emulation.setGeolocationOverride", {
+      coordinates: geolocation ? {
+        latitude: geolocation.latitude,
+        longitude: geolocation.longitude,
+        accuracy: geolocation.accuracy
+      } : null,
+      userContexts: [this._userContextId()]
+    });
   }
-  async setExtraHTTPHeaders(headers) {
+  async doUpdateExtraHTTPHeaders() {
   }
   async setUserAgent(userAgent) {
   }
-  async setOffline(offline) {
+  async doUpdateOffline() {
   }
   async doSetHTTPCredentials(httpCredentials) {
     this._options.httpCredentials = httpCredentials;
     for (const page of this.pages())
-      await page._delegate.updateHttpCredentials();
+      await page.delegate.updateHttpCredentials();
   }
   async doAddInitScript(initScript) {
     const { script } = await this._browser._browserSession.send("script.addPreloadScript", {
       // TODO: remove function call from the source.
       functionDeclaration: `() => { return ${initScript.source} }`,
-      userContexts: [this._browserContextId || "default"]
+      userContexts: [this._userContextId()]
     });
-    if (!initScript.internal)
-      this._initScriptIds.push(script);
-  }
-  async doRemoveNonInternalInitScripts() {
-    const promise = Promise.all(this._initScriptIds.map((script) => this._browser._browserSession.send("script.removePreloadScript", { script })));
-    this._initScriptIds = [];
-    await promise;
+    this._initScriptIds.set(initScript, script);
+  }
+  async doRemoveInitScripts(initScripts) {
+    const ids = [];
+    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((script) => this._browser._browserSession.send("script.removePreloadScript", { script })));
   }
   async doUpdateRequestInterception() {
   }
+  async doUpdateDefaultViewport() {
+    if (!this._options.viewport)
+      return;
+    await this._browser._browserSession.send("browsingContext.setViewport", {
+      viewport: {
+        width: this._options.viewport.width,
+        height: this._options.viewport.height
+      },
+      devicePixelRatio: this._options.deviceScaleFactor || 1,
+      userContexts: [this._userContextId()]
+    });
+  }
+  async doUpdateDefaultEmulatedMedia() {
+  }
+  async doExposePlaywrightBinding() {
+    const args = [{
+      type: "channel",
+      value: {
+        channel: import_bidiPage.kPlaywrightBindingChannel,
+        ownership: bidi.Script.ResultOwnership.Root
+      }
+    }];
+    const functionDeclaration = `function addMainBinding(callback) { globalThis['${import_page.PageBinding.kBindingName}'] = callback; }`;
+    const promises = [];
+    promises.push(this._browser._browserSession.send("script.addPreloadScript", {
+      functionDeclaration,
+      arguments: args,
+      userContexts: [this._userContextId()]
+    }));
+    promises.push(...this._bidiPages().map((page) => {
+      const realms = [...page._realmToContext].filter(([realm, context]) => context.world === "main").map(([realm, context]) => realm);
+      return Promise.all(realms.map((realm) => {
+        return page._session.send("script.callFunction", {
+          functionDeclaration,
+          arguments: args,
+          target: { realm },
+          awaitPromise: false,
+          userActivation: false
+        });
+      }));
+    }));
+    await Promise.all(promises);
+  }
   onClosePersistent() {
   }
   async clearCache() {
@@ -363,6 +399,36 @@ function toBidiSameSite(sameSite) {
   }
   return bidi.Network.SameSite.None;
 }
+function getProxyConfiguration(proxySettings) {
+  if (!proxySettings)
+    return void 0;
+  const proxy = {
+    proxyType: "manual"
+  };
+  const url = new URL(proxySettings.server);
+  switch (url.protocol) {
+    case "http:":
+      proxy.httpProxy = url.host;
+      break;
+    case "https:":
+      proxy.sslProxy = url.host;
+      break;
+    case "socks4:":
+      proxy.socksProxy = url.host;
+      proxy.socksVersion = 4;
+      break;
+    case "socks5:":
+      proxy.socksProxy = url.host;
+      proxy.socksVersion = 5;
+      break;
+    default:
+      throw new Error("Invalid proxy server protocol: " + proxySettings.server);
+  }
+  const bypass = proxySettings.bypass ?? process.env.PLAYWRIGHT_PROXY_BYPASS_FOR_TESTING;
+  if (bypass)
+    proxy.noProxy = bypass.split(",");
+  return proxy;
+}
 var Network;
 ((Network2) => {
   let SameSite;