patchright-core 1.52.5 → 1.55.1

package/lib/server/trace/viewer/traceViewer.js

@@ -42,7 +42,6 @@ var import_utils = require("../../../utils");
 var import_utils2 = require("../../../utils");
 var import_httpServer = require("../../utils/httpServer");
 var import_utilsBundle = require("../../../utilsBundle");
-var import_instrumentation = require("../../instrumentation");
 var import_launchApp = require("../../launchApp");
 var import_launchApp2 = require("../../launchApp");
 var import_playwright = require("../../playwright");
@@ -125,14 +124,6 @@ async function installRootRedirect(server, traceUrls, options) {
   server.routePath("/", (_, response) => {
     response.statusCode = 302;
     response.setHeader("Location", urlPath);
-    if (process.env.EXPERIMENTAL_OPENAI_API_KEY)
-      response.appendHeader("Set-Cookie", `openai_api_key=${process.env.EXPERIMENTAL_OPENAI_API_KEY}`);
-    if (process.env.OPENAI_BASE_URL)
-      response.appendHeader("Set-Cookie", `openai_base_url=${process.env.OPENAI_BASE_URL}`);
-    if (process.env.EXPERIMENTAL_ANTHROPIC_API_KEY)
-      response.appendHeader("Set-Cookie", `anthropic_api_key=${process.env.EXPERIMENTAL_ANTHROPIC_API_KEY}`);
-    if (process.env.ANTHROPIC_BASE_URL)
-      response.appendHeader("Set-Cookie", `anthropic_base_url=${process.env.ANTHROPIC_BASE_URL}`);
     response.end();
     return true;
   });
@@ -156,28 +147,28 @@ async function openTraceViewerApp(url, browserName, options) {
   const traceViewerPlaywright = (0, import_playwright.createPlaywright)({ sdkLanguage: "javascript", isInternalPlaywright: true });
   const traceViewerBrowser = (0, import_utils2.isUnderTest)() ? "chromium" : browserName;
   const { context, page } = await (0, import_launchApp2.launchApp)(traceViewerPlaywright[traceViewerBrowser], {
-    // TODO: store language in the trace.
     sdkLanguage: traceViewerPlaywright.options.sdkLanguage,
     windowSize: { width: 1280, height: 800 },
     persistentContextOptions: {
       ...options?.persistentContextOptions,
-      useWebSocket: (0, import_utils2.isUnderTest)(),
+      cdpPort: (0, import_utils2.isUnderTest)() ? 0 : void 0,
       headless: !!options?.headless,
       colorScheme: (0, import_utils2.isUnderTest)() ? "light" : void 0
     }
   });
-  const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), context._browser);
+  const controller = new import_progress.ProgressController();
   await controller.run(async (progress) => {
     await context._browser._defaultContext._loadDefaultContextAsIs(progress);
+    if (process.env.PWTEST_PRINT_WS_ENDPOINT) {
+      process.stderr.write("DevTools listening on: " + context._browser.options.wsEndpoint + "\n");
+    }
+    if (!(0, import_utils2.isUnderTest)())
+      await (0, import_launchApp.syncLocalStorageWithSettings)(page, "traceviewer");
+    if ((0, import_utils2.isUnderTest)())
+      page.on("close", () => context.close({ reason: "Trace viewer closed" }).catch(() => {
+      }));
+    await page.mainFrame().goto(progress, url);
   });
-  if (process.env.PWTEST_PRINT_WS_ENDPOINT)
-    process.stderr.write("DevTools listening on: " + context._browser.options.wsEndpoint + "\n");
-  if (!(0, import_utils2.isUnderTest)())
-    await (0, import_launchApp.syncLocalStorageWithSettings)(page, "traceviewer");
-  if ((0, import_utils2.isUnderTest)())
-    page.on("close", () => context.close({ reason: "Trace viewer closed" }).catch(() => {
-    }));
-  await page.mainFrame().goto((0, import_instrumentation.serverSideCallMetadata)(), url);
   return page;
 }
 async function openTraceInBrowser(url) {

package/lib/server/transport.js

@@ -43,8 +43,6 @@ class WebSocketTransport {
     this._ws = new import_utilsBundle.ws(url, [], {
       maxPayload: 256 * 1024 * 1024,
       // 256Mb,
-      // Prevent internal http client error when passing negative timeout.
-      handshakeTimeout: Math.max(progress?.timeUntilDeadline() ?? 3e4, 1),
       headers: options.headers,
       followRedirects: options.followRedirects,
       agent: /^(https|wss):\/\//.test(url) ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent,
@@ -99,15 +97,10 @@ class WebSocketTransport {
     const logUrl = stripQueryParams(url);
     progress?.log(`<ws connecting> ${logUrl}`);
     const transport = new WebSocketTransport(progress, url, logUrl, { ...options, followRedirects: !!options.followRedirects && hadRedirects });
-    let success = false;
-    progress?.cleanupWhenAborted(async () => {
-      if (!success)
-        await transport.closeAndWait().catch((e) => null);
-    });
-    const result = await new Promise((fulfill, reject) => {
+    const resultPromise = new Promise((fulfill, reject) => {
       transport._ws.on("open", async () => {
         progress?.log(`<ws connected> ${logUrl}`);
-        fulfill({ transport });
+        fulfill({});
       });
       transport._ws.on("error", (event) => {
         progress?.log(`<ws connect error> ${logUrl} ${event.message}`);
@@ -136,20 +129,25 @@ ${Buffer.concat(chunks)}` : errorPrefix;
         });
       });
     });
-    if (result.redirect) {
-      const newHeaders = Object.fromEntries(Object.entries(options.headers || {}).filter(([name]) => {
-        return !name.includes("access-key") && name.toLowerCase() !== "authorization";
-      }));
-      return WebSocketTransport._connect(
-        progress,
-        result.redirect.headers.location,
-        { ...options, headers: newHeaders },
-        true
-        /* hadRedirects */
-      );
+    try {
+      const result = progress ? await progress.race(resultPromise) : await resultPromise;
+      if (result.redirect) {
+        const newHeaders = Object.fromEntries(Object.entries(options.headers || {}).filter(([name]) => {
+          return !name.includes("access-key") && name.toLowerCase() !== "authorization";
+        }));
+        return WebSocketTransport._connect(
+          progress,
+          result.redirect.headers.location,
+          { ...options, headers: newHeaders },
+          true
+          /* hadRedirects */
+        );
+      }
+      return transport;
+    } catch (error) {
+      await transport.closeAndWait();
+      throw error;
     }
-    success = true;
-    return transport;
   }
   send(message) {
     this._ws.send(JSON.stringify(message));

package/lib/server/utils/comparators.js

@@ -121,9 +121,9 @@ function compareText(actual, expectedBuffer) {
   const lines = import_utilsBundle2.diff.createPatch("file", expected, actual, void 0, void 0, { context: 5 }).split("\n");
   const coloredLines = lines.slice(4).map((line) => {
     if (line.startsWith("-"))
-      return import_utilsBundle2.colors.red(line);
-    if (line.startsWith("+"))
       return import_utilsBundle2.colors.green(line);
+    if (line.startsWith("+"))
+      return import_utilsBundle2.colors.red(line);
     if (line.startsWith("@@"))
       return import_utilsBundle2.colors.dim(line);
     return line;

package/lib/server/utils/debug.js

@@ -19,8 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var debug_exports = {};
 __export(debug_exports, {
   debugMode: () => debugMode,
-  isUnderTest: () => isUnderTest,
-  setUnderTest: () => setUnderTest
+  isUnderTest: () => isUnderTest
 });
 module.exports = __toCommonJS(debug_exports);
 var import_env = require("./env");
@@ -32,16 +31,12 @@ function debugMode() {
     return "";
   return _debugMode ? "inspector" : "";
 }
-let _isUnderTest = !!process.env.PWTEST_UNDER_TEST;
-function setUnderTest() {
-  _isUnderTest = true;
-}
+const _isUnderTest = (0, import_env.getAsBooleanFromENV)("PWTEST_UNDER_TEST");
 function isUnderTest() {
   return _isUnderTest;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   debugMode,
-  isUnderTest,
-  setUnderTest
+  isUnderTest
 });

package/lib/server/utils/debugLogger.js

@@ -95,17 +95,25 @@ const kLogCount = 150;
 class RecentLogsCollector {
   constructor() {
     this._logs = [];
+    this._listeners = [];
   }
   log(message) {
     this._logs.push(message);
     if (this._logs.length === kLogCount * 2)
       this._logs.splice(0, kLogCount);
+    for (const listener of this._listeners)
+      listener(message);
   }
   recentLogs() {
     if (this._logs.length > kLogCount)
       return this._logs.slice(-kLogCount);
     return this._logs;
   }
+  onMessage(listener) {
+    for (const message of this._logs)
+      listener(message);
+    this._listeners.push(listener);
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/utils/hostPlatform.js

@@ -92,8 +92,10 @@ function calculatePlatform() {
         return { hostPlatform: "debian11" + archSuffix, isOfficiallySupportedPlatform: isOfficiallySupportedPlatform2 };
       if (distroInfo?.version === "12")
         return { hostPlatform: "debian12" + archSuffix, isOfficiallySupportedPlatform: isOfficiallySupportedPlatform2 };
+      if (distroInfo?.version === "13")
+        return { hostPlatform: "debian13" + archSuffix, isOfficiallySupportedPlatform: isOfficiallySupportedPlatform2 };
       if (distroInfo?.version === "")
-        return { hostPlatform: "debian12" + archSuffix, isOfficiallySupportedPlatform: isOfficiallySupportedPlatform2 };
+        return { hostPlatform: "debian13" + archSuffix, isOfficiallySupportedPlatform: isOfficiallySupportedPlatform2 };
     }
     return { hostPlatform: "ubuntu20.04" + archSuffix, isOfficiallySupportedPlatform: false };
   }

package/lib/server/utils/network.js

@@ -44,6 +44,7 @@ var import_https = __toESM(require("https"));
 var import_url = __toESM(require("url"));
 var import_utilsBundle = require("../../utilsBundle");
 var import_happyEyeballs = require("./happyEyeballs");
+var import_manualPromise = require("../../utils/isomorphic/manualPromise");
 const NET_DEFAULT_TIMEOUT = 3e4;
 function httpRequest(params, onResponse, onError) {
   const parsedUrl = import_url.default.parse(params.url);
@@ -55,7 +56,6 @@ function httpRequest(params, onResponse, onError) {
   };
   if (params.rejectUnauthorized !== void 0)
     options.rejectUnauthorized = params.rejectUnauthorized;
-  const timeout = params.timeout ?? NET_DEFAULT_TIMEOUT;
   const proxyURL = (0, import_utilsBundle.getProxyForUrl)(params.url);
   if (proxyURL) {
     const parsedProxyURL = import_url.default.parse(proxyURL);
@@ -73,44 +73,54 @@ function httpRequest(params, onResponse, onError) {
       options.rejectUnauthorized = false;
     }
   }
+  let cancelRequest;
   const requestCallback = (res) => {
     const statusCode = res.statusCode || 0;
     if (statusCode >= 300 && statusCode < 400 && res.headers.location) {
       request.destroy();
-      httpRequest({ ...params, url: new URL(res.headers.location, params.url).toString() }, onResponse, onError);
+      cancelRequest = httpRequest({ ...params, url: new URL(res.headers.location, params.url).toString() }, onResponse, onError).cancel;
     } else {
       onResponse(res);
     }
   };
   const request = options.protocol === "https:" ? import_https.default.request(options, requestCallback) : import_http.default.request(options, requestCallback);
   request.on("error", onError);
-  if (timeout !== void 0) {
-    const rejectOnTimeout = () => {
-      onError(new Error(`Request to ${params.url} timed out after ${timeout}ms`));
+  if (params.socketTimeout !== void 0) {
+    request.setTimeout(params.socketTimeout, () => {
+      onError(new Error(`Request to ${params.url} timed out after ${params.socketTimeout}ms`));
       request.abort();
-    };
-    if (timeout <= 0) {
-      rejectOnTimeout();
-      return;
-    }
-    request.setTimeout(timeout, rejectOnTimeout);
+    });
   }
+  cancelRequest = (e) => {
+    try {
+      request.destroy(e);
+    } catch {
+    }
+  };
   request.end(params.data);
+  return { cancel: (e) => cancelRequest(e) };
 }
-function fetchData(params, onError) {
-  return new Promise((resolve, reject) => {
-    httpRequest(params, async (response) => {
-      if (response.statusCode !== 200) {
-        const error = onError ? await onError(params, response) : new Error(`fetch failed: server returned code ${response.statusCode}. URL: ${params.url}`);
-        reject(error);
-        return;
-      }
-      let body = "";
-      response.on("data", (chunk) => body += chunk);
-      response.on("error", (error) => reject(error));
-      response.on("end", () => resolve(body));
-    }, reject);
-  });
+async function fetchData(progress, params, onError) {
+  const promise = new import_manualPromise.ManualPromise();
+  const { cancel } = httpRequest(params, async (response) => {
+    if (response.statusCode !== 200) {
+      const error = onError ? await onError(params, response) : new Error(`fetch failed: server returned code ${response.statusCode}. URL: ${params.url}`);
+      promise.reject(error);
+      return;
+    }
+    let body = "";
+    response.on("data", (chunk) => body += chunk);
+    response.on("error", (error) => promise.reject(error));
+    response.on("end", () => promise.resolve(body));
+  }, (error) => promise.reject(error));
+  if (!progress)
+    return promise;
+  try {
+    return await progress.race(promise);
+  } catch (error) {
+    cancel(error);
+    throw error;
+  }
 }
 function shouldBypassProxy(url2, bypass) {
   if (!bypass)

package/lib/server/utils/nodePlatform.js

@@ -84,7 +84,7 @@ const nodePlatform = {
   fs: () => import_fs.default,
   env: process.env,
   inspectCustom: util.inspect.custom,
-  isDebugMode: () => !!(0, import_debug.debugMode)(),
+  isDebugMode: () => (0, import_debug.debugMode)() === "inspector",
   isJSDebuggerAttached: () => !!require("inspector").url(),
   isLogEnabled(name) {
     return import_debugLogger.debugLogger.isEnabled(name);

package/lib/server/utils/processLauncher.js

@@ -132,7 +132,10 @@ async function launchProcess(options) {
     spawnedProcess.once("error", (error) => {
       failed(new Error("Failed to launch: " + error));
     });
-    return cleanup().then(() => failedPromise).then((e) => Promise.reject(e));
+    return failedPromise.then(async (error) => {
+      await cleanup();
+      throw error;
+    });
   }
   options.log(`<launched> pid=${spawnedProcess.pid}`);
   const stdout = readline.createInterface({ input: spawnedProcess.stdout });

package/lib/server/utils/wsServer.js

@@ -43,16 +43,7 @@ class WSServer {
   }
   async listen(port = 0, hostname, path) {
     import_debugLogger.debugLogger.log("server", `Server started at ${/* @__PURE__ */ new Date()}`);
-    const server = (0, import_network.createHttpServer)((request, response) => {
-      if (request.method === "GET" && request.url === "/json") {
-        response.setHeader("Content-Type", "application/json");
-        response.end(JSON.stringify({
-          wsEndpointPath: path
-        }));
-        return;
-      }
-      response.end("Running");
-    });
+    const server = (0, import_network.createHttpServer)(this._delegate.onRequest);
     server.on("error", (error) => import_debugLogger.debugLogger.log("server", String(error)));
     this.server = server;
     const wsEndpoint = await new Promise((resolve, reject) => {
@@ -71,8 +62,7 @@ class WSServer {
       noServer: true,
       perMessageDeflate
     });
-    if (this._delegate.onHeaders)
-      this._wsServer.on("headers", (headers) => this._delegate.onHeaders(headers));
+    this._wsServer.on("headers", (headers) => this._delegate.onHeaders(headers));
     server.on("upgrade", (request, socket, head) => {
       const pathname = new URL("http://localhost" + request.url).pathname;
       if (pathname !== path) {
@@ -82,21 +72,26 @@ class WSServer {
         socket.destroy();
         return;
       }
-      const upgradeResult = this._delegate.onUpgrade?.(request, socket);
+      const upgradeResult = this._delegate.onUpgrade(request, socket);
       if (upgradeResult) {
         socket.write(upgradeResult.error);
         socket.destroy();
         return;
       }
-      this._wsServer?.handleUpgrade(request, socket, head, (ws) => this._wsServer?.emit("connection", ws, request));
+      this._wsServer.handleUpgrade(request, socket, head, (ws) => this._wsServer.emit("connection", ws, request));
     });
     this._wsServer.on("connection", (ws, request) => {
       import_debugLogger.debugLogger.log("server", "Connected client ws.extension=" + ws.extensions);
       const url = new URL("http://localhost" + (request.url || ""));
       const id = String(++lastConnectionId);
       import_debugLogger.debugLogger.log("server", `[${id}] serving connection: ${request.url}`);
-      const connection = this._delegate.onConnection(request, url, ws, id);
-      ws[kConnectionSymbol] = connection;
+      try {
+        const connection = this._delegate.onConnection(request, url, ws, id);
+        ws[kConnectionSymbol] = connection;
+      } catch (error) {
+        import_debugLogger.debugLogger.log("server", `[${id}] connection error: ${error}`);
+        ws.close(1011, String(error));
+      }
     });
     return wsEndpoint;
   }
@@ -122,7 +117,6 @@ class WSServer {
     this._wsServer = void 0;
     this.server = void 0;
     import_debugLogger.debugLogger.log("server", "closed server");
-    await this._delegate.onClose?.();
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/webkit/webkit.js

@@ -43,8 +43,11 @@ class WebKit extends import_browserType.BrowserType {
   connectToTransport(transport, options) {
     return import_wkBrowser.WKBrowser.connect(this.attribution.playwright, transport, options);
   }
-  amendEnvironment(env, userDataDir, executable, browserArguments) {
-    return { ...env, CURL_COOKIE_JAR_PATH: import_path.default.join(userDataDir, "cookiejar.db") };
+  amendEnvironment(env, userDataDir, isPersistent) {
+    return {
+      ...env,
+      CURL_COOKIE_JAR_PATH: process.platform === "win32" && isPersistent ? import_path.default.join(userDataDir, "cookiejar.db") : void 0
+    };
   }
   doRewriteStartupLog(error) {
     if (!error.logs)

package/lib/server/webkit/wkBrowser.js

@@ -39,8 +39,8 @@ var network = __toESM(require("../network"));
 var import_wkConnection = require("./wkConnection");
 var import_wkPage = require("./wkPage");
 var import_errors = require("../errors");
-const DEFAULT_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15";
-const BROWSER_VERSION = "18.4";
+const BROWSER_VERSION = "26.0";
+const DEFAULT_USER_AGENT = `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/${BROWSER_VERSION} Safari/605.1.15`;
 class WKBrowser extends import_browser.Browser {
   constructor(parent, transport, options) {
     super(parent, options);
@@ -110,7 +110,7 @@ class WKBrowser extends import_browser.Browser {
     const page = this._wkPages.get(payload.pageProxyId);
     if (!page)
       return;
-    page._page._frameManager.frameAbortedNavigation(payload.frameId, "Download is starting");
+    page._page.frameManager.frameAbortedNavigation(payload.frameId, "Download is starting");
     let originPage = page._page.initializedOrUndefined();
     if (!originPage) {
       page._firstNonInitialNavigationCommittedReject(new Error("Starting new page download"));
@@ -152,8 +152,8 @@ class WKBrowser extends import_browser.Browser {
     const wkPage = this._wkPages.get(pageProxyId);
     if (!wkPage)
       return;
-    wkPage.didClose();
     this._wkPages.delete(pageProxyId);
+    wkPage.didClose();
   }
   _onPageProxyMessageReceived(event) {
     const wkPage = this._wkPages.get(event.pageProxyId);
@@ -199,7 +199,7 @@ class WKBrowserContext extends import_browserContext.BrowserContext {
     if (this._options.geolocation)
       promises.push(this.setGeolocation(this._options.geolocation));
     if (this._options.offline)
-      promises.push(this.setOffline(this._options.offline));
+      promises.push(this.doUpdateOffline());
     if (this._options.httpCredentials)
       promises.push(this.setHTTPCredentials(this._options.httpCredentials));
     await Promise.all(promises);
@@ -211,35 +211,52 @@ class WKBrowserContext extends import_browserContext.BrowserContext {
     return this._wkPages().map((wkPage) => wkPage._page);
   }
   async doCreateNewPage() {
-    (0, import_browserContext.assertBrowserContextIsNotOwned)(this);
     const { pageProxyId } = await this._browser._browserSession.send("Playwright.createPage", { browserContextId: this._browserContextId });
     return this._browser._wkPages.get(pageProxyId)._page;
   }
   async doGetCookies(urls) {
     const { cookies } = await this._browser._browserSession.send("Playwright.getAllCookies", { browserContextId: this._browserContextId });
     return network.filterCookies(cookies.map((c) => {
-      const copy = { ...c };
-      copy.expires = c.expires === -1 ? -1 : c.expires / 1e3;
-      delete copy.session;
+      const { name, value, domain, path, expires, httpOnly, secure, sameSite } = c;
+      const copy = {
+        name,
+        value,
+        domain,
+        path,
+        expires: expires === -1 ? -1 : expires / 1e3,
+        httpOnly,
+        secure,
+        sameSite
+      };
       return copy;
     }), urls);
   }
   async addCookies(cookies) {
-    const cc = network.rewriteCookies(cookies).map((c) => ({
-      ...c,
-      session: c.expires === -1 || c.expires === void 0,
-      expires: c.expires && c.expires !== -1 ? c.expires * 1e3 : c.expires
-    }));
+    const cc = network.rewriteCookies(cookies).map((c) => {
+      const { name, value, domain, path, expires, httpOnly, secure, sameSite } = c;
+      const copy = {
+        name,
+        value,
+        domain,
+        path,
+        expires: expires && expires !== -1 ? expires * 1e3 : expires,
+        httpOnly,
+        secure,
+        sameSite,
+        session: expires === -1 || expires === void 0
+      };
+      return copy;
+    });
     await this._browser._browserSession.send("Playwright.setCookies", { cookies: cc, browserContextId: this._browserContextId });
   }
   async doClearCookies() {
     await this._browser._browserSession.send("Playwright.deleteAllCookies", { browserContextId: this._browserContextId });
   }
   async doGrantPermissions(origin, permissions) {
-    await Promise.all(this.pages().map((page) => page._delegate._grantPermissions(origin, permissions)));
+    await Promise.all(this.pages().map((page) => page.delegate._grantPermissions(origin, permissions)));
   }
   async doClearPermissions() {
-    await Promise.all(this.pages().map((page) => page._delegate._clearPermissions()));
+    await Promise.all(this.pages().map((page) => page.delegate._clearPermissions()));
   }
   async setGeolocation(geolocation) {
     (0, import_browserContext.verifyGeolocation)(geolocation);
@@ -247,37 +264,43 @@ class WKBrowserContext extends import_browserContext.BrowserContext {
     const payload = geolocation ? { ...geolocation, timestamp: Date.now() } : void 0;
     await this._browser._browserSession.send("Playwright.setGeolocationOverride", { browserContextId: this._browserContextId, geolocation: payload });
   }
-  async setExtraHTTPHeaders(headers) {
-    this._options.extraHTTPHeaders = headers;
+  async doUpdateExtraHTTPHeaders() {
     for (const page of this.pages())
-      await page._delegate.updateExtraHTTPHeaders();
+      await page.delegate.updateExtraHTTPHeaders();
   }
   async setUserAgent(userAgent) {
     this._options.userAgent = userAgent;
     for (const page of this.pages())
-      await page._delegate.updateUserAgent();
+      await page.delegate.updateUserAgent();
   }
-  async setOffline(offline) {
-    this._options.offline = offline;
+  async doUpdateOffline() {
     for (const page of this.pages())
-      await page._delegate.updateOffline();
+      await page.delegate.updateOffline();
   }
   async doSetHTTPCredentials(httpCredentials) {
     this._options.httpCredentials = httpCredentials;
     for (const page of this.pages())
-      await page._delegate.updateHttpCredentials();
+      await page.delegate.updateHttpCredentials();
   }
   async doAddInitScript(initScript) {
     for (const page of this.pages())
-      await page._delegate._updateBootstrapScript();
+      await page.delegate._updateBootstrapScript();
   }
-  async doRemoveNonInternalInitScripts() {
+  async doRemoveInitScripts(initScripts) {
     for (const page of this.pages())
-      await page._delegate._updateBootstrapScript();
+      await page.delegate._updateBootstrapScript();
   }
   async doUpdateRequestInterception() {
     for (const page of this.pages())
-      await page._delegate.updateRequestInterception();
+      await page.delegate.updateRequestInterception();
+  }
+  async doUpdateDefaultViewport() {
+  }
+  async doUpdateDefaultEmulatedMedia() {
+  }
+  async doExposePlaywrightBinding() {
+    for (const page of this.pages())
+      await page.delegate.exposePlaywrightBinding();
   }
   onClosePersistent() {
   }

package/lib/server/webkit/wkExecutionContext.js

@@ -36,6 +36,7 @@ var js = __toESM(require("../javascript"));
 var dom = __toESM(require("../dom"));
 var import_protocolError = require("../protocolError");
 var import_assert = require("../../utils/isomorphic/assert");
+var import_utilityScriptSerializers = require("../../utils/isomorphic/utilityScriptSerializers");
 class WKExecutionContext {
   constructor(session, contextId) {
     this._session = session;
@@ -86,7 +87,7 @@ class WKExecutionContext {
       if (response.wasThrown)
         throw new js.JavaScriptErrorInEvaluate(response.result.description);
       if (returnByValue)
-        return js.parseEvaluationResultValue(response.result.value);
+        return (0, import_utilityScriptSerializers.parseEvaluationResultValue)(response.result.value);
       return createHandle(utilityScript._context, response.result);
     } catch (error) {
       throw rewriteError(error);