patchright-core 1.57.0 → 1.58.2

package/lib/server/bidi/bidiBrowser.js

@@ -130,10 +130,13 @@ class BidiBrowser extends import_browser.Browser {
       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 +145,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);
@@ -217,6 +221,8 @@ 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));
     await Promise.all(promises);
   }
   possiblyUninitializedPages() {
@@ -275,17 +281,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", {
@@ -349,21 +372,42 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
     await Promise.all(ids.map((script) => this._browser._browserSession.send("script.removePreloadScript", { script })));
   }
   async doUpdateRequestInterception() {
+    if (this.requestInterceptors.length > 0 && !this._interceptId) {
+      const { intercept } = await this._browser._browserSession.send("network.addIntercept", {
+        phases: [bidi.Network.InterceptPhase.BeforeRequestSent],
+        urlPatterns: [{ type: "pattern" }]
+      });
+      this._interceptId = intercept;
+    }
+    if (this.requestInterceptors.length === 0 && this._interceptId) {
+      const intercept = this._interceptId;
+      this._interceptId = void 0;
+      await this._browser._browserSession.send("network.removeIntercept", { intercept });
+    }
   }
   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()]
       })
     ]);

package/lib/server/bidi/bidiChromium.js

@@ -38,6 +38,7 @@ var import_bidiBrowser = require("./bidiBrowser");
 var import_bidiConnection = require("./bidiConnection");
 var import_chromiumSwitches = require("../chromium/chromiumSwitches");
 var import_chromium = require("../chromium/chromium");
+var import_hostPlatform = require("../utils/hostPlatform");
 class BidiChromium extends import_browserType.BrowserType {
   constructor(parent) {
     super(parent, "chromium");
@@ -56,14 +57,12 @@ class BidiChromium extends import_browserType.BrowserType {
       throw e;
     }
   }
-  doRewriteStartupLog(error) {
-    if (!error.logs)
-      return error;
-    if (error.logs.includes("Missing X server"))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
-    if (!error.logs.includes("crbug.com/357670") && !error.logs.includes("No usable sandbox!") && !error.logs.includes("crbug.com/638180"))
-      return error;
-    error.logs = [
+  doRewriteStartupLog(logs) {
+    if (logs.includes("Missing X server"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    if (!logs.includes("crbug.com/357670") && !logs.includes("No usable sandbox!") && !logs.includes("crbug.com/638180"))
+      return logs;
+    return [
       `Chromium sandboxing failed!`,
       `================================`,
       `To avoid the sandboxing issue, do either of the following:`,
@@ -72,7 +71,6 @@ class BidiChromium extends import_browserType.BrowserType {
       `================================`,
       ``
     ].join("\n");
-    return error;
   }
   amendEnvironment(env) {
     return env;
@@ -109,11 +107,9 @@ class BidiChromium extends import_browserType.BrowserType {
     if (args.find((arg) => !arg.startsWith("-")))
       throw new Error("Arguments can not specify page to be opened");
     const chromeArguments = [...(0, import_chromiumSwitches.chromiumSwitches)(options.assistantMode)];
-    if (import_os.default.platform() === "darwin") {
+    if (import_os.default.platform() !== "darwin" || !(0, import_hostPlatform.hasGpuMac)()) {
       chromeArguments.push("--enable-unsafe-swiftshader");
     }
-    if (options.devtools)
-      chromeArguments.push("--auto-open-devtools-for-tabs");
     if (options.headless) {
       chromeArguments.push("--headless");
       chromeArguments.push(

package/lib/server/bidi/bidiConnection.js

@@ -173,6 +173,7 @@ class BidiSession extends import_events.EventEmitter {
     this._browsingContexts.clear();
     for (const callback of this._callbacks.values()) {
       callback.error.type = this._crashed ? "crashed" : "closed";
+      callback.error.setMessage(`Internal server error, session ${callback.error.type}.`);
       callback.error.logs = this.connection._browserDisconnectedLogs;
       callback.reject(callback.error);
     }

package/lib/server/bidi/bidiDeserializer.js

@@ -0,0 +1,116 @@
+"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 bidiDeserializer_exports = {};
+__export(bidiDeserializer_exports, {
+  deserializeBidiValue: () => deserializeBidiValue
+});
+module.exports = __toCommonJS(bidiDeserializer_exports);
+var import_javascript = require("../javascript");
+function deserializeBidiValue(result, internalIdMap = /* @__PURE__ */ new Map()) {
+  switch (result.type) {
+    case "undefined":
+      return void 0;
+    case "null":
+      return null;
+    case "number":
+      return typeof result.value === "number" ? result.value : (0, import_javascript.parseUnserializableValue)(result.value);
+    case "boolean":
+      return Boolean(result.value);
+    case "string":
+      return result.value;
+    case "bigint":
+      return BigInt(result.value);
+    case "array":
+      return deserializeBidiList(result, internalIdMap);
+    case "arraybuffer":
+      return getValue(result, internalIdMap, () => ({}));
+    case "date":
+      return getValue(result, internalIdMap, () => new Date(result.value));
+    case "error":
+      return getValue(result, internalIdMap, () => {
+        const error = new Error();
+        error.stack = "";
+        return error;
+      });
+    case "function":
+      return void 0;
+    case "generator":
+      return getValue(result, internalIdMap, () => ({}));
+    case "htmlcollection":
+      return { ...deserializeBidiList(result, internalIdMap) };
+    case "map":
+      return getValue(result, internalIdMap, () => ({}));
+    case "node":
+      return "ref: <Node>";
+    case "nodelist":
+      return { ...deserializeBidiList(result, internalIdMap) };
+    case "object":
+      return deserializeBidiMapping(result, internalIdMap);
+    case "promise":
+      return getValue(result, internalIdMap, () => ({}));
+    case "proxy":
+      return getValue(result, internalIdMap, () => ({}));
+    case "regexp":
+      return getValue(result, internalIdMap, () => new RegExp(result.value.pattern, result.value.flags));
+    case "set":
+      return getValue(result, internalIdMap, () => ({}));
+    case "symbol":
+      return void 0;
+    case "typedarray":
+      return void 0;
+    case "weakmap":
+      return getValue(result, internalIdMap, () => ({}));
+    case "weakset":
+      return getValue(result, internalIdMap, () => ({}));
+    case "window":
+      return "ref: <Window>";
+  }
+}
+function getValue(bidiValue, internalIdMap, defaultValue) {
+  if ("internalId" in bidiValue && bidiValue.internalId) {
+    if (internalIdMap.has(bidiValue.internalId)) {
+      return internalIdMap.get(bidiValue.internalId);
+    } else {
+      const value = defaultValue();
+      internalIdMap.set(bidiValue.internalId, value);
+      return value;
+    }
+  } else {
+    return defaultValue();
+  }
+}
+function deserializeBidiList(bidiValue, internalIdMap) {
+  const result = getValue(bidiValue, internalIdMap, () => []);
+  for (const val of bidiValue.value || [])
+    result.push(deserializeBidiValue(val, internalIdMap));
+  return result;
+}
+function deserializeBidiMapping(bidiValue, internalIdMap) {
+  const result = getValue(bidiValue, internalIdMap, () => ({}));
+  for (const [serializedKey, serializedValue] of bidiValue.value || []) {
+    const key = typeof serializedKey === "string" ? serializedKey : deserializeBidiValue(serializedKey, internalIdMap);
+    const value = deserializeBidiValue(serializedValue, internalIdMap);
+    result[key] = value;
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deserializeBidiValue
+});

package/lib/server/bidi/bidiExecutionContext.js

@@ -36,9 +36,9 @@ var import_utils = require("../../utils");
 var import_utilityScriptSerializers = require("../../utils/isomorphic/utilityScriptSerializers");
 var js = __toESM(require("../javascript"));
 var dom = __toESM(require("../dom"));
-var import_bidiDeserializer = require("./third_party/bidiDeserializer");
 var bidi = __toESM(require("./third_party/bidiProtocol"));
 var import_bidiSerializer = require("./third_party/bidiSerializer");
+var import_bidiDeserializer = require("./bidiDeserializer");
 class BidiExecutionContext {
   constructor(session, realmInfo) {
     this._session = session;
@@ -65,7 +65,7 @@ class BidiExecutionContext {
       userActivation: true
     });
     if (response.type === "success")
-      return import_bidiDeserializer.BidiDeserializer.deserialize(response.result);
+      return (0, import_bidiDeserializer.deserializeBidiValue)(response.result);
     if (response.type === "exception")
       throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text);
     throw new js.JavaScriptErrorInEvaluate("Unexpected response type: " + JSON.stringify(response));
@@ -108,7 +108,7 @@ class BidiExecutionContext {
       throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text);
     if (response.type === "success") {
       if (returnByValue)
-        return (0, import_utilityScriptSerializers.parseEvaluationResultValue)(import_bidiDeserializer.BidiDeserializer.deserialize(response.result));
+        return (0, import_utilityScriptSerializers.parseEvaluationResultValue)((0, import_bidiDeserializer.deserializeBidiValue)(response.result));
       return createHandle(utilityScript._context, response.result);
     }
     throw new js.JavaScriptErrorInEvaluate("Unexpected response type: " + JSON.stringify(response));
@@ -123,7 +123,10 @@ class BidiExecutionContext {
       }
       return names2;
     });
-    const values = await Promise.all(names.map((name) => handle.evaluateHandle((object, name2) => object[name2], name)));
+    const values = await Promise.all(names.map(async (name) => {
+      const value = await this._rawCallFunction("(object, name) => object[name]", [{ handle: handle._objectId }, { type: "string", value: name }], true, false);
+      return createHandle(handle._context, value);
+    }));
     const map = /* @__PURE__ */ new Map();
     for (let i = 0; i < names.length; i++)
       map.set(names[i], values[i]);
@@ -152,7 +155,7 @@ class BidiExecutionContext {
     return createHandle(context, result);
   }
   async contentFrameIdForFrame(handle) {
-    const contentWindow = await this._rawCallFunction("e => e.contentWindow", { handle: handle._objectId });
+    const contentWindow = await this._rawCallFunction("e => e.contentWindow", [{ handle: handle._objectId }]);
     if (contentWindow?.type === "window")
       return contentWindow.value.context;
     return null;
@@ -166,17 +169,17 @@ class BidiExecutionContext {
     return null;
   }
   async _remoteValueForReference(reference, createHandle2) {
-    return await this._rawCallFunction("e => e", reference, createHandle2);
+    return await this._rawCallFunction("e => e", [reference], createHandle2);
   }
-  async _rawCallFunction(functionDeclaration, arg, createHandle2) {
+  async _rawCallFunction(functionDeclaration, args, createHandle2, awaitPromise = true) {
     const response = await this._session.send("script.callFunction", {
       functionDeclaration,
       target: this._target,
-      arguments: [arg],
+      arguments: args,
       // "Root" is necessary for the handle to be returned.
       resultOwnership: createHandle2 ? bidi.Script.ResultOwnership.Root : bidi.Script.ResultOwnership.None,
       serializationOptions: { maxObjectDepth: 0, maxDomDepth: 0 },
-      awaitPromise: true,
+      awaitPromise,
       userActivation: true
     });
     if (response.type === "exception")
@@ -186,25 +189,65 @@ class BidiExecutionContext {
     throw new js.JavaScriptErrorInEvaluate("Unexpected response type: " + JSON.stringify(response));
   }
 }
-function renderPreview(remoteObject) {
-  if (remoteObject.type === "undefined")
-    return "undefined";
-  if (remoteObject.type === "null")
-    return "null";
-  if ("value" in remoteObject)
-    return String(remoteObject.value);
-  return `<${remoteObject.type}>`;
-}
-function remoteObjectValue(remoteObject) {
-  if (remoteObject.type === "undefined")
-    return void 0;
-  if (remoteObject.type === "null")
-    return null;
-  if (remoteObject.type === "number" && typeof remoteObject.value === "string")
-    return js.parseUnserializableValue(remoteObject.value);
-  if ("value" in remoteObject)
-    return remoteObject.value;
-  return void 0;
+function renderPreview(remoteObject, nested = false) {
+  switch (remoteObject.type) {
+    case "undefined":
+    case "null":
+      return remoteObject.type;
+    case "number":
+    case "boolean":
+    case "string":
+      return String(remoteObject.value);
+    case "bigint":
+      return `${remoteObject.value}n`;
+    case "date":
+      return String(new Date(remoteObject.value));
+    case "regexp":
+      return String(new RegExp(remoteObject.value.pattern, remoteObject.value.flags));
+    case "node":
+      return remoteObject.value?.localName || "Node";
+    case "object":
+      if (nested)
+        return "Object";
+      const tokens = [];
+      for (const [name, value] of remoteObject.value || []) {
+        if (typeof name === "string")
+          tokens.push(`${name}: ${renderPreview(value, true)}`);
+      }
+      return `{${tokens.join(", ")}}`;
+    case "array":
+    case "htmlcollection":
+    case "nodelist":
+      if (nested || !remoteObject.value)
+        return remoteObject.value ? `Array(${remoteObject.value.length})` : "Array";
+      return `[${remoteObject.value.map((v) => renderPreview(v, true)).join(", ")}]`;
+    case "map":
+      return remoteObject.value ? `Map(${remoteObject.value.length})` : "Map";
+    case "set":
+      return remoteObject.value ? `Set(${remoteObject.value.length})` : "Set";
+    case "arraybuffer":
+      return "ArrayBuffer";
+    case "error":
+      return "Error";
+    case "function":
+      return "Function";
+    case "generator":
+      return "Generator";
+    case "promise":
+      return "Promise";
+    case "proxy":
+      return "Proxy";
+    case "symbol":
+      return "Symbol()";
+    case "typedarray":
+      return "TypedArray";
+    case "weakmap":
+      return "WeakMap";
+    case "weakset":
+      return "WeakSet";
+    case "window":
+      return "Window";
+  }
 }
 function createHandle(context, remoteObject) {
   if (remoteObject.type === "node") {
@@ -212,7 +255,10 @@ function createHandle(context, remoteObject) {
     return new dom.ElementHandle(context, remoteObject.handle);
   }
   const objectId = "handle" in remoteObject ? remoteObject.handle : void 0;
-  return new js.JSHandle(context, remoteObject.type, renderPreview(remoteObject), objectId, remoteObjectValue(remoteObject));
+  const preview = renderPreview(remoteObject);
+  const handle = new js.JSHandle(context, remoteObject.type, preview, objectId, (0, import_bidiDeserializer.deserializeBidiValue)(remoteObject));
+  handle._setPreview(preview);
+  return handle;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/bidi/bidiFirefox.js

@@ -49,15 +49,13 @@ class BidiFirefox extends import_browserType.BrowserType {
   async connectToTransport(transport, options) {
     return import_bidiBrowser.BidiBrowser.connect(this.attribution.playwright, transport, options);
   }
-  doRewriteStartupLog(error) {
-    if (!error.logs)
-      return error;
-    if (error.logs.includes(`as root in a regular user's session is not supported.`))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(`Firefox is unable to launch if the $HOME folder isn't owned by the current user.
+  doRewriteStartupLog(logs) {
+    if (logs.includes(`as root in a regular user's session is not supported.`))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(`Firefox is unable to launch if the $HOME folder isn't owned by the current user.
 Workaround: Set the HOME=/root environment variable${process.env.GITHUB_ACTION ? " in your GitHub Actions workflow file" : ""} when running Playwright.`, 1);
-    if (error.logs.includes("no DISPLAY environment variable specified"))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
-    return error;
+    if (logs.includes("no DISPLAY environment variable specified"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    return logs;
   }
   amendEnvironment(env) {
     if (!import_path.default.isAbsolute(import_os.default.homedir()))

package/lib/server/bidi/bidiNetworkManager.js

@@ -342,7 +342,7 @@ function resourceTypeFromBidi(requestDestination, requestInitiatorType, eventIni
     case "image":
       return "image";
     case "object":
-      return "object";
+      return "other";
     case "paintworklet":
       return "script";
     case "script":

package/lib/server/bidi/bidiPage.js

@@ -32,6 +32,7 @@ __export(bidiPage_exports, {
   kPlaywrightBindingChannel: () => kPlaywrightBindingChannel
 });
 module.exports = __toCommonJS(bidiPage_exports);
+var import_debugLogger = require("../utils/debugLogger");
 var import_eventsHelper = require("../utils/eventsHelper");
 var dialog = __toESM(require("../dialog"));
 var dom = __toESM(require("../dom"));
@@ -87,8 +88,7 @@ class BidiPage {
   async _initialize() {
     this._onFrameAttached(this._session.sessionId, null);
     await Promise.all([
-      this.updateHttpCredentials(),
-      this.updateRequestInterception()
+      this.updateHttpCredentials()
       // If the page is created by the Playwright client's call, some initialization
       // may be pending. Wait for it to complete before reporting the page as new.
     ]);
@@ -179,10 +179,12 @@ class BidiPage {
   }
   _onNavigationCommitted(params) {
     const frameId = params.context;
+    const frame = this._page.frameManager.frame(frameId);
+    this._browserContext.doGrantGlobalPermissionsForURL(params.url).catch((error) => import_debugLogger.debugLogger.log("error", error));
     this._page.frameManager.frameCommittedNewDocumentNavigation(
       frameId,
       params.url,
-      "",
+      frame._name,
       params.navigation,
       /* initial */
       false
@@ -263,7 +265,7 @@ ${params.stackTrace?.callFrames.map((f) => {
       return;
     const callFrame = params.stackTrace?.callFrames[0];
     const location = callFrame ?? { url: "", lineNumber: 1, columnNumber: 1 };
-    this._page.addConsoleMessage(null, entry.method, entry.args.map((arg) => (0, import_bidiExecutionContext.createHandle)(context, arg)), location, params.text || void 0);
+    this._page.addConsoleMessage(null, entry.method, entry.args.map((arg) => (0, import_bidiExecutionContext.createHandle)(context, arg)), location);
   }
   async _onFileDialogOpened(params) {
     if (!params.element)
@@ -272,8 +274,11 @@ ${params.stackTrace?.callFrames.map((f) => {
     if (!frame)
       return;
     const executionContext = await frame._mainContext();
-    const handle = await toBidiExecutionContext(executionContext).remoteObjectForNodeId(executionContext, { sharedId: params.element.sharedId });
-    await this._page._onFileChooserOpened(handle);
+    try {
+      const handle = await toBidiExecutionContext(executionContext).remoteObjectForNodeId(executionContext, { sharedId: params.element.sharedId });
+      await this._page._onFileChooserOpened(handle);
+    } catch {
+    }
   }
   async navigateFrame(frame, url, referrer) {
     const { navigation } = await this._session.send("browsingContext.navigate", {
@@ -306,6 +311,7 @@ ${params.stackTrace?.callFrames.map((f) => {
     const emulatedSize = this._page.emulatedSize();
     if (!emulatedSize)
       return;
+    const screenSize = emulatedSize.screen;
     const viewportSize = emulatedSize.viewport;
     await Promise.all([
       this._session.send("browsingContext.setViewport", {
@@ -318,12 +324,19 @@ ${params.stackTrace?.callFrames.map((f) => {
       }),
       this._session.send("emulation.setScreenOrientationOverride", {
         contexts: [this._session.sessionId],
-        screenOrientation: (0, import_bidiBrowser.getScreenOrientation)(!!options.isMobile, viewportSize)
+        screenOrientation: (0, import_bidiBrowser.getScreenOrientation)(!!options.isMobile, screenSize)
+      }),
+      this._session.send("emulation.setScreenSettingsOverride", {
+        contexts: [this._session.sessionId],
+        screenArea: {
+          width: screenSize.width,
+          height: screenSize.height
+        }
       })
     ]);
   }
   async updateRequestInterception() {
-    await this._networkManager.setRequestInterception(this._page.needsRequestInterception());
+    await this._networkManager.setRequestInterception(this._page.requestInterceptors.length > 0);
   }
   async updateOffline() {
   }
@@ -482,7 +495,9 @@ ${params.stackTrace?.callFrames.map((f) => {
       throw e;
     });
   }
-  async setScreencastOptions(options) {
+  async startScreencast(options) {
+  }
+  async stopScreencast() {
   }
   rafCountForStablePosition() {
     return 1;
@@ -537,26 +552,22 @@ ${params.stackTrace?.callFrames.map((f) => {
     const parent = frame.parentFrame();
     if (!parent)
       throw new Error("Frame has been detached.");
-    const parentContext = await parent._mainContext();
-    const list = await parentContext.evaluateHandle(() => {
-      return [...document.querySelectorAll("iframe,frame")];
-    });
-    const length = await list.evaluate((list2) => list2.length);
-    let foundElement = null;
-    for (let i = 0; i < length; i++) {
-      const element = await list.evaluateHandle((list2, i2) => list2[i2], i);
-      const candidate = await element.contentFrame();
-      if (frame === candidate) {
-        foundElement = element;
-        break;
-      } else {
-        element.dispose();
-      }
-    }
-    list.dispose();
-    if (!foundElement)
+    const node = await this._getFrameNode(frame);
+    if (!node?.sharedId)
       throw new Error("Frame has been detached.");
-    return foundElement;
+    const parentFrameExecutionContext = await parent._mainContext();
+    return await toBidiExecutionContext(parentFrameExecutionContext).remoteObjectForNodeId(parentFrameExecutionContext, { sharedId: node.sharedId });
+  }
+  async _getFrameNode(frame) {
+    const parent = frame.parentFrame();
+    if (!parent)
+      return void 0;
+    const result = await this._session.send("browsingContext.locateNodes", {
+      context: parent._id,
+      locator: { type: "context", value: { context: frame._id } }
+    });
+    const node = result.nodes[0];
+    return node;
   }
   shouldToggleStyleSheetToSyncAnimations() {
     return true;

package/lib/server/bidi/third_party/bidiProtocolCore.js

@@ -128,6 +128,7 @@ var Network;
 ((Network2) => {
   let DataType;
   ((DataType2) => {
+    DataType2["Request"] = "request";
     DataType2["Response"] = "response";
   })(DataType = Network2.DataType || (Network2.DataType = {}));
 })(Network || (Network = {}));