patchright-core 1.57.0 → 1.59.0

package/lib/protocol/validatorPrimitives.js

@@ -101,7 +101,7 @@ const tBinary = (arg, path, context) => {
     return arg.toString("base64");
   }
   if (context.binary === "buffer") {
-    if (!(arg instanceof Buffer))
+    if (!(arg instanceof Buffer) && !(arg instanceof Object))
       throw new ValidationError(`${path}: expected Buffer, got ${typeof arg}`);
     return arg;
   }

package/lib/remote/playwrightConnection.js

@@ -29,10 +29,10 @@ var import_profiler = require("../server/utils/profiler");
 var import_utils = require("../utils");
 var import_debugLogger = require("../server/utils/debugLogger");
 class PlaywrightConnection {
-  constructor(semaphore, ws, controller, playwright, initialize, id) {
+  constructor(semaphore, transport, controller, playwright, initialize, id) {
     this._cleanups = [];
     this._disconnected = false;
-    this._ws = ws;
+    this._transport = transport;
     this._semaphore = semaphore;
     this._id = id;
     this._profileName = (/* @__PURE__ */ new Date()).toISOString();
@@ -40,16 +40,16 @@ class PlaywrightConnection {
     this._dispatcherConnection = new import_server.DispatcherConnection();
     this._dispatcherConnection.onmessage = async (message) => {
       await lock;
-      if (ws.readyState !== ws.CLOSING) {
+      if (!transport.isClosed()) {
         const messageString = JSON.stringify(message);
         if (import_debugLogger.debugLogger.isEnabled("server:channel"))
           import_debugLogger.debugLogger.log("server:channel", `[${this._id}] ${(0, import_utils.monotonicTime)() * 1e3} SEND \u25BA ${messageString}`);
         if (import_debugLogger.debugLogger.isEnabled("server:metadata"))
           this.logServerMetadata(message, messageString, "SEND");
-        ws.send(messageString);
+        transport.send(messageString);
       }
     };
-    ws.on("message", async (message) => {
+    transport.on("message", async (message) => {
       await lock;
       const messageString = Buffer.from(message).toString();
       const jsonMessage = JSON.parse(messageString);
@@ -59,8 +59,8 @@ class PlaywrightConnection {
         this.logServerMetadata(jsonMessage, messageString, "RECV");
       this._dispatcherConnection.dispatch(jsonMessage);
     });
-    ws.on("close", () => this._onDisconnect());
-    ws.on("error", (error) => this._onDisconnect(error));
+    transport.on("close", () => this._onDisconnect());
+    transport.on("error", (error) => this._onDisconnect(error));
     if (controller) {
       import_debugLogger.debugLogger.log("server", `[${this._id}] engaged reuse controller mode`);
       this._root = new import_debugControllerDispatcher.DebugControllerDispatcher(this._dispatcherConnection, playwright.debugController);
@@ -90,6 +90,8 @@ class PlaywrightConnection {
     });
   }
   async _onDisconnect(error) {
+    if (this._disconnected)
+      return;
     this._disconnected = true;
     import_debugLogger.debugLogger.log("server", `[${this._id}] disconnected. error: ${error}`);
     await this._root.stopPendingOperations(new Error("Disconnected")).catch(() => {
@@ -118,7 +120,7 @@ class PlaywrightConnection {
       return;
     import_debugLogger.debugLogger.log("server", `[${this._id}] force closing connection: ${reason?.reason || ""} (${reason?.code || 0})`);
     try {
-      this._ws.close(reason?.code, reason?.reason);
+      this._transport.close(reason);
     } catch (e) {
     }
   }

package/lib/remote/playwrightPipeServer.js

@@ -0,0 +1,100 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var playwrightPipeServer_exports = {};
+__export(playwrightPipeServer_exports, {
+  PlaywrightPipeServer: () => PlaywrightPipeServer
+});
+module.exports = __toCommonJS(playwrightPipeServer_exports);
+var import_net = __toESM(require("net"));
+var import_fs = __toESM(require("fs"));
+var import_playwrightConnection = require("./playwrightConnection");
+var import_serverTransport = require("./serverTransport");
+var import_debugLogger = require("../server/utils/debugLogger");
+var import_browser = require("../server/browser");
+var import_utils = require("../utils");
+class PlaywrightPipeServer {
+  constructor(browser) {
+    this._connections = /* @__PURE__ */ new Set();
+    this._connectionId = 0;
+    this._browser = browser;
+    browser.on(import_browser.Browser.Events.Disconnected, () => this.close());
+  }
+  async listen(pipeName) {
+    if (!pipeName.startsWith("\\\\.\\pipe\\")) {
+      try {
+        import_fs.default.unlinkSync(pipeName);
+      } catch {
+      }
+    }
+    this._server = import_net.default.createServer((socket) => {
+      const id = String(++this._connectionId);
+      import_debugLogger.debugLogger.log("server", `[${id}] pipe client connected`);
+      const transport = new import_serverTransport.SocketServerTransport(socket);
+      const connection = new import_playwrightConnection.PlaywrightConnection(
+        new import_utils.Semaphore(1),
+        transport,
+        false,
+        this._browser.attribution.playwright,
+        () => this._initPreLaunchedBrowserMode(id),
+        id
+      );
+      this._connections.add(connection);
+      transport.on("close", () => this._connections.delete(connection));
+    });
+    (0, import_utils.decorateServer)(this._server);
+    await new Promise((resolve, reject) => {
+      this._server.listen(pipeName, () => resolve());
+      this._server.on("error", reject);
+    });
+    import_debugLogger.debugLogger.log("server", `Pipe server listening at ${pipeName}`);
+  }
+  async _initPreLaunchedBrowserMode(id) {
+    import_debugLogger.debugLogger.log("server", `[${id}] engaged pre-launched (browser) pipe mode`);
+    return {
+      preLaunchedBrowser: this._browser,
+      sharedBrowser: true,
+      denyLaunch: true
+    };
+  }
+  async close() {
+    if (!this._server)
+      return;
+    import_debugLogger.debugLogger.log("server", "closing pipe server");
+    for (const connection of this._connections)
+      await connection.close({ code: 1001, reason: "Server closing" });
+    this._connections.clear();
+    await new Promise((f) => this._server.close(() => f()));
+    this._server = void 0;
+    import_debugLogger.debugLogger.log("server", "closed pipe server");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlaywrightPipeServer
+});

package/lib/remote/playwrightServer.js

@@ -22,6 +22,7 @@ __export(playwrightServer_exports, {
 });
 module.exports = __toCommonJS(playwrightServer_exports);
 var import_playwrightConnection = require("./playwrightConnection");
+var import_serverTransport = require("./serverTransport");
 var import_playwright = require("../server/playwright");
 var import_semaphore = require("../utils/isomorphic/semaphore");
 var import_time = require("../utils/isomorphic/time");
@@ -86,6 +87,8 @@ ${uaError}` };
         const isExtension = this._options.mode === "extension";
         const allowFSPaths = isExtension;
         launchOptions = filterLaunchOptions(launchOptions, allowFSPaths);
+        if (this._options.artifactsDir)
+          launchOptions.artifactsDir = this._options.artifactsDir;
         if (isExtension) {
           const connectFilter = url.searchParams.get("connect");
           if (connectFilter) {
@@ -93,7 +96,7 @@ ${uaError}` };
               throw new Error(`Unknown connect filter: ${connectFilter}`);
             return new import_playwrightConnection.PlaywrightConnection(
               browserSemaphore,
-              ws,
+              new import_serverTransport.WebSocketServerTransport(ws),
               false,
               this._playwright,
               () => this._initConnectMode(id, connectFilter, browserName, launchOptions),
@@ -103,7 +106,7 @@ ${uaError}` };
           if (url.searchParams.has("debug-controller")) {
             return new import_playwrightConnection.PlaywrightConnection(
               controllerSemaphore,
-              ws,
+              new import_serverTransport.WebSocketServerTransport(ws),
               true,
               this._playwright,
               async () => {
@@ -114,7 +117,7 @@ ${uaError}` };
           }
           return new import_playwrightConnection.PlaywrightConnection(
             reuseBrowserSemaphore,
-            ws,
+            new import_serverTransport.WebSocketServerTransport(ws),
             false,
             this._playwright,
             () => this._initReuseBrowsersMode(browserName, launchOptions, id),
@@ -125,7 +128,7 @@ ${uaError}` };
           if (this._options.preLaunchedBrowser) {
             return new import_playwrightConnection.PlaywrightConnection(
               browserSemaphore,
-              ws,
+              new import_serverTransport.WebSocketServerTransport(ws),
               false,
               this._playwright,
               () => this._initPreLaunchedBrowserMode(id),
@@ -134,7 +137,7 @@ ${uaError}` };
           }
           return new import_playwrightConnection.PlaywrightConnection(
             browserSemaphore,
-            ws,
+            new import_serverTransport.WebSocketServerTransport(ws),
             false,
             this._playwright,
             () => this._initPreLaunchedAndroidMode(id),
@@ -143,7 +146,7 @@ ${uaError}` };
         }
         return new import_playwrightConnection.PlaywrightConnection(
           browserSemaphore,
-          ws,
+          new import_serverTransport.WebSocketServerTransport(ws),
           false,
           this._playwright,
           () => this._initLaunchBrowserMode(browserName, proxyValue, launchOptions, id),
@@ -313,7 +316,8 @@ function filterLaunchOptions(options, allowFSPaths) {
     firefoxUserPrefs: options.firefoxUserPrefs,
     slowMo: options.slowMo,
     executablePath: (0, import_utils.isUnderTest)() || allowFSPaths ? options.executablePath : void 0,
-    downloadsPath: allowFSPaths ? options.downloadsPath : void 0
+    downloadsPath: allowFSPaths ? options.downloadsPath : void 0,
+    artifactsDir: (0, import_utils.isUnderTest)() || allowFSPaths ? options.artifactsDir : void 0
   };
 }
 const defaultLaunchOptions = {
@@ -321,13 +325,13 @@ const defaultLaunchOptions = {
   handleSIGINT: false,
   handleSIGTERM: false,
   handleSIGHUP: false,
-  headless: true,
-  devtools: false
+  headless: true
 };
 const optionsThatAllowBrowserReuse = [
   "headless",
   "timeout",
-  "tracesDir"
+  "tracesDir",
+  "artifactsDir"
 ];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/remote/playwrightWebSocketServer.js

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var playwrightWebSocketServer_exports = {};
+__export(playwrightWebSocketServer_exports, {
+  PlaywrightWebSocketServer: () => PlaywrightWebSocketServer
+});
+module.exports = __toCommonJS(playwrightWebSocketServer_exports);
+var import_playwrightConnection = require("./playwrightConnection");
+var import_serverTransport = require("./serverTransport");
+var import_debugLogger = require("../server/utils/debugLogger");
+var import_browser = require("../server/browser");
+var import_utils = require("../utils");
+var import_wsServer = require("../server/utils/wsServer");
+class PlaywrightWebSocketServer {
+  constructor(browser, path) {
+    this._browser = browser;
+    browser.on(import_browser.Browser.Events.Disconnected, () => this.close());
+    const semaphore = new import_utils.Semaphore(Infinity);
+    this._wsServer = new import_wsServer.WSServer({
+      onRequest: (request, response) => {
+        response.end("Running");
+      },
+      onUpgrade: () => void 0,
+      onHeaders: () => {
+      },
+      onConnection: (request, url, ws, id) => {
+        import_debugLogger.debugLogger.log("server", `[${id}] ws client connected`);
+        return new import_playwrightConnection.PlaywrightConnection(
+          semaphore,
+          new import_serverTransport.WebSocketServerTransport(ws),
+          false,
+          this._browser.attribution.playwright,
+          () => this._initPreLaunchedBrowserMode(id),
+          id
+        );
+      }
+    });
+  }
+  async _initPreLaunchedBrowserMode(id) {
+    import_debugLogger.debugLogger.log("server", `[${id}] engaged pre-launched (browser) ws mode`);
+    return {
+      preLaunchedBrowser: this._browser,
+      sharedBrowser: true,
+      denyLaunch: true
+    };
+  }
+  async listen(port = 0, hostname, path) {
+    return await this._wsServer.listen(port, hostname, path || "/");
+  }
+  async close() {
+    await this._wsServer.close();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlaywrightWebSocketServer
+});

package/lib/remote/serverTransport.js

@@ -0,0 +1,96 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serverTransport_exports = {};
+__export(serverTransport_exports, {
+  SocketServerTransport: () => SocketServerTransport,
+  WebSocketServerTransport: () => WebSocketServerTransport
+});
+module.exports = __toCommonJS(serverTransport_exports);
+var import_events = require("events");
+class WebSocketServerTransport {
+  constructor(ws) {
+    this._ws = ws;
+  }
+  send(message) {
+    this._ws.send(message);
+  }
+  close(reason) {
+    this._ws.close(reason?.code, reason?.reason);
+  }
+  on(event, handler) {
+    this._ws.on(event, handler);
+  }
+  isClosed() {
+    return this._ws.readyState === this._ws.CLOSING || this._ws.readyState === this._ws.CLOSED;
+  }
+}
+class SocketServerTransport extends import_events.EventEmitter {
+  constructor(socket) {
+    super();
+    this._closed = false;
+    this._pendingBuffers = [];
+    this._socket = socket;
+    socket.on("data", (buffer) => this._dispatch(buffer));
+    socket.on("close", () => {
+      this._closed = true;
+      super.emit("close");
+    });
+    socket.on("error", (error) => {
+      super.emit("error", error);
+    });
+  }
+  send(message) {
+    if (this._closed)
+      return;
+    this._socket.write(message);
+    this._socket.write("\0");
+  }
+  close(reason) {
+    if (this._closed)
+      return;
+    this._closed = true;
+    this._socket.end();
+  }
+  isClosed() {
+    return this._closed;
+  }
+  _dispatch(buffer) {
+    let end = buffer.indexOf("\0");
+    if (end === -1) {
+      this._pendingBuffers.push(buffer);
+      return;
+    }
+    this._pendingBuffers.push(buffer.slice(0, end));
+    const message = Buffer.concat(this._pendingBuffers).toString();
+    super.emit("message", message);
+    let start = end + 1;
+    end = buffer.indexOf("\0", start);
+    while (end !== -1) {
+      super.emit("message", buffer.toString(void 0, start, end));
+      start = end + 1;
+      end = buffer.indexOf("\0", start);
+    }
+    this._pendingBuffers = [buffer.slice(start)];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SocketServerTransport,
+  WebSocketServerTransport
+});

package/lib/server/android/android.js

@@ -261,7 +261,7 @@ class AndroidDevice extends import_instrumentation.SdkObject {
       const proxyBypassRules = [];
       if (proxy.bypass)
         proxyBypassRules.push(...proxy.bypass.split(",").map((t) => t.trim()).map((t) => t.startsWith(".") ? "*" + t : t));
-      if (!process.env.PLAYWRIGHT_DISABLE_FORCED_CHROMIUM_PROXIED_LOOPBACK && !proxyBypassRules.includes("<-loopback>"))
+      if ((0, import_crBrowser.shouldProxyLoopback)(proxy.bypass))
         proxyBypassRules.push("<-loopback>");
       if (proxyBypassRules.length > 0)
         chromeArguments.push(`--proxy-bypass-list=${proxyBypassRules.join(";")}`);
@@ -294,7 +294,7 @@ class AndroidDevice extends import_instrumentation.SdkObject {
       });
       const browserOptions = {
         name: "clank",
-        isChromium: true,
+        browserType: "chromium",
         slowMo: 0,
         persistent: { ...options, noDefaultViewport: true },
         artifactsDir,

package/lib/server/artifact.js

@@ -103,7 +103,7 @@ class Artifact extends import_instrumentation.SdkObject {
     if (!this._unaccessibleErrorMessage)
       await import_fs.default.promises.unlink(this._localPath).catch((e) => {
       });
-    await this.reportFinished(new import_errors.TargetClosedError());
+    await this.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
   }
   async reportFinished(error) {
     if (this._finished)

package/lib/server/bidi/bidiBrowser.js

@@ -48,6 +48,7 @@ class BidiBrowser extends import_browser.Browser {
     super(parent, options);
     this._contexts = /* @__PURE__ */ new Map();
     this._bidiPages = /* @__PURE__ */ new Map();
+    this._cacheBehavior = "default";
     this._connection = new import_bidiConnection.BidiConnection(transport, this._onDisconnect.bind(this), options.protocolLogger, options.browserLogsCollector);
     this._browserSession = this._connection.browserSession;
     this._eventListeners = [
@@ -84,6 +85,7 @@ class BidiBrowser extends import_browser.Browser {
         "input"
       ]
     });
+    await browser._browserSession.send("network.addIntercept", { phases: [bidi.Network.InterceptPhase.AuthRequired] });
     await browser._browserSession.send("network.addDataCollector", {
       dataTypes: [bidi.Network.DataType.Response],
       maxEncodedDataSize: 2e7
@@ -124,16 +126,27 @@ class BidiBrowser extends import_browser.Browser {
   isConnected() {
     return !this._connection.isClosed();
   }
+  async updateCacheBehavior() {
+    const cacheBehavior = [...this._contexts.values()].some((context) => context.requestInterceptors.length > 0) ? "bypass" : "default";
+    if (this._cacheBehavior !== cacheBehavior) {
+      await this._browserSession.send("network.setCacheBehavior", { cacheBehavior });
+      this._cacheBehavior = cacheBehavior;
+    }
+  }
   _onBrowsingContextCreated(event) {
     if (event.parent) {
       const parentFrameId = event.parent;
       const page2 = this._findPageForFrame(parentFrameId);
       if (page2) {
         page2._session.addFrameBrowsingContext(event.context);
-        page2._page.frameManager.frameAttached(event.context, parentFrameId);
-        const frame = page2._page.frameManager.frame(event.context);
-        if (frame)
-          frame._url = event.url;
+        const frame = page2._page.frameManager.frameAttached(event.context, parentFrameId);
+        frame._url = event.url;
+        page2._getFrameNode(frame).then((node) => {
+          const attributes = node?.value?.attributes;
+          frame._name = attributes?.name ?? attributes?.id ?? "";
+        }, () => {
+        });
+        return;
       }
       return;
     }
@@ -142,6 +155,7 @@ class BidiBrowser extends import_browser.Browser {
       context = this._defaultContext;
     if (!context)
       return;
+    context.doGrantGlobalPermissionsForURL(event.url);
     const session = this._connection.createMainFrameBrowsingContextSession(event.context);
     const opener = event.originalOpener && this._findPageForFrame(event.originalOpener);
     const page = new import_bidiPage.BidiPage(context, session, opener || null);
@@ -194,6 +208,11 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
     const promises = [
       super._initialize()
     ];
+    const downloadBehavior = this._options.acceptDownloads === "accept" ? { type: "allowed", destinationFolder: this._browser.options.downloadsPath } : { type: "denied" };
+    promises.push(this._browser._browserSession.send("browser.setDownloadBehavior", {
+      downloadBehavior,
+      userContexts: [this._userContextId()]
+    }));
     promises.push(this.doUpdateDefaultViewport());
     if (this._options.geolocation)
       promises.push(this.setGeolocation(this._options.geolocation));
@@ -217,6 +236,10 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
     }
     if (this._options.extraHTTPHeaders)
       promises.push(this.doUpdateExtraHTTPHeaders());
+    if (this._options.permissions)
+      promises.push(this.doGrantPermissions("*", this._options.permissions));
+    if (this._options.offline)
+      promises.push(this.doUpdateOffline());
     await Promise.all(promises);
   }
   possiblyUninitializedPages() {
@@ -263,7 +286,7 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
       };
       return this._browser._browserSession.send(
         "storage.setCookie",
-        { cookie, partition: { type: "storageKey", userContext: this._browserContextId } }
+        { cookie, partition: { type: "storageKey", userContext: this._browserContextId, sourceOrigin: c.partitionKey } }
       );
     });
     await Promise.all(promises);
@@ -275,17 +298,34 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
     );
   }
   async doGrantPermissions(origin, permissions) {
+    if (origin === "null")
+      return;
     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)));
+    if (origin === "*") {
+      await Promise.all(this._bidiPages().flatMap(
+        (page) => page._page.frames().map(
+          (frame) => this.doGrantPermissions(new URL(frame._url).origin, permissions)
+        )
+      ));
+    } else {
+      await Promise.all(toGrant.map((permission) => this._setPermission(origin, permission, bidi.Permissions.PermissionState.Granted)));
+    }
+  }
+  async doGrantGlobalPermissionsForURL(url) {
+    const permissions = this._originToPermissions.get("*");
+    if (!permissions)
+      return;
+    await this.doGrantPermissions(new URL(url).origin, permissions);
   }
   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)
-    )));
+    await Promise.all(currentPermissions.flatMap(([origin, permissions]) => {
+      if (origin !== "*")
+        return permissions.map((p) => this._setPermission(origin, p, bidi.Permissions.PermissionState.Prompt));
+    }));
   }
   async _setPermission(origin, permission, state) {
     await this._browser._browserSession.send("permissions.setPermission", {
@@ -324,6 +364,10 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
     });
   }
   async doUpdateOffline() {
+    await this._browser._browserSession.send("emulation.setNetworkConditions", {
+      networkConditions: this._options.offline ? { type: "offline" } : null,
+      userContexts: [this._userContextId()]
+    });
   }
   async doSetHTTPCredentials(httpCredentials) {
     this._options.httpCredentials = httpCredentials;
@@ -349,21 +393,42 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
     await Promise.all(ids.map((script) => this._browser._browserSession.send("script.removePreloadScript", { script })));
   }
   async doUpdateRequestInterception() {
+    let interceptPromise = Promise.resolve(void 0);
+    if (this.requestInterceptors.length > 0 && !this._interceptId) {
+      interceptPromise = this._browser._browserSession.send("network.addIntercept", {
+        phases: [bidi.Network.InterceptPhase.BeforeRequestSent]
+      }).then(({ intercept }) => this._interceptId = intercept);
+    }
+    if (this.requestInterceptors.length === 0 && this._interceptId) {
+      const intercept = this._interceptId;
+      this._interceptId = void 0;
+      interceptPromise = this._browser._browserSession.send("network.removeIntercept", { intercept });
+    }
+    await Promise.all([this._browser.updateCacheBehavior(), interceptPromise]);
   }
   async doUpdateDefaultViewport() {
-    if (!this._options.viewport)
+    if (!this._options.viewport && !this._options.screen)
       return;
+    const screenSize = this._options.screen || this._options.viewport;
+    const viewportSize = this._options.viewport || this._options.screen;
     await Promise.all([
       this._browser._browserSession.send("browsingContext.setViewport", {
         viewport: {
-          width: this._options.viewport.width,
-          height: this._options.viewport.height
+          width: viewportSize.width,
+          height: viewportSize.height
         },
         devicePixelRatio: this._options.deviceScaleFactor || 1,
         userContexts: [this._userContextId()]
       }),
       this._browser._browserSession.send("emulation.setScreenOrientationOverride", {
-        screenOrientation: getScreenOrientation(!!this._options.isMobile, this._options.viewport),
+        screenOrientation: getScreenOrientation(!!this._options.isMobile, screenSize),
+        userContexts: [this._userContextId()]
+      }),
+      this._browser._browserSession.send("emulation.setScreenSettingsOverride", {
+        screenArea: {
+          width: screenSize.width,
+          height: screenSize.height
+        },
         userContexts: [this._userContextId()]
       })
     ]);
@@ -386,7 +451,7 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
       userContexts: [this._userContextId()]
     }));
     promises.push(...this._bidiPages().map((page) => {
-      const realms = [...page._realmToContext].filter(([realm, context]) => context.world === "main").map(([realm, context]) => realm);
+      const realms = [...page._contextIdToContext].filter(([realm, context]) => context.world === "main").map(([realm, context]) => realm);
       return Promise.all(realms.map((realm) => {
         return page._session.send("script.callFunction", {
           functionDeclaration,
@@ -411,6 +476,7 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
     await this._browser._browserSession.send("browser.removeUserContext", {
       userContext: this._browserContextId
     });
+    await Promise.all(this._bidiPages().map((bidiPage) => bidiPage._page.closedPromise));
     this._browser._contexts.delete(this._browserContextId);
   }
   async cancelDownload(uuid) {