patchright-core 1.57.0 → 1.58.2

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

@@ -47,20 +47,21 @@ var import_launchApp2 = require("../../launchApp");
 var import_playwright = require("../../playwright");
 var import_progress = require("../../progress");
 const tracesDirMarker = "traces.dir";
-function validateTraceUrl(traceUrl) {
-  if (!traceUrl)
-    return traceUrl;
-  if (traceUrl.startsWith("http://") || traceUrl.startsWith("https://"))
-    return traceUrl;
-  if (traceUrl.endsWith(".json"))
-    return traceUrl;
+function validateTraceUrlOrPath(traceFileOrUrl) {
+  if (!traceFileOrUrl)
+    return traceFileOrUrl;
+  if (traceFileOrUrl.startsWith("http://") || traceFileOrUrl.startsWith("https://"))
+    return traceFileOrUrl;
+  let traceFile = traceFileOrUrl;
+  if (traceFile.endsWith(".json"))
+    return toFilePathUrl(traceFile);
   try {
-    const stat = import_fs.default.statSync(traceUrl);
+    const stat = import_fs.default.statSync(traceFile);
     if (stat.isDirectory())
-      return import_path.default.join(traceUrl, tracesDirMarker);
-    return traceUrl;
+      traceFile = import_path.default.join(traceFile, tracesDirMarker);
+    return toFilePathUrl(traceFile);
   } catch {
-    throw new Error(`Trace file ${traceUrl} does not exist!`);
+    throw new Error(`Trace file ${traceFileOrUrl} does not exist!`);
   }
 }
 async function startTraceViewerServer(options) {
@@ -126,7 +127,7 @@ async function installRootRedirect(server, traceUrl, options) {
   });
 }
 async function runTraceViewerApp(traceUrl, browserName, options, exitOnClose) {
-  traceUrl = validateTraceUrl(traceUrl);
+  traceUrl = validateTraceUrlOrPath(traceUrl);
   const server = await startTraceViewerServer(options);
   await installRootRedirect(server, traceUrl, options);
   const page = await openTraceViewerApp(server.urlPrefix("precise"), browserName, options);
@@ -135,7 +136,7 @@ async function runTraceViewerApp(traceUrl, browserName, options, exitOnClose) {
   return page;
 }
 async function runTraceInBrowser(traceUrl, options) {
-  traceUrl = validateTraceUrl(traceUrl);
+  traceUrl = validateTraceUrlOrPath(traceUrl);
   const server = await startTraceViewerServer(options);
   await installRootRedirect(server, traceUrl, options);
   await openTraceInBrowser(server.urlPrefix("human-readable"));
@@ -177,8 +178,8 @@ async function openTraceInBrowser(url) {
 class StdinServer {
   constructor() {
     process.stdin.on("data", (data) => {
-      const url = data.toString().trim();
-      if (url === this._traceUrl)
+      const url = validateTraceUrlOrPath(data.toString().trim());
+      if (!url || url === this._traceUrl)
         return;
       if (url.endsWith(".json"))
         this._pollLoadTrace(url);
@@ -221,15 +222,18 @@ function traceDescriptor(traceDir, tracePrefix) {
   };
   for (const name of import_fs.default.readdirSync(traceDir)) {
     if (!tracePrefix || name.startsWith(tracePrefix))
-      result.entries.push({ name, path: import_path.default.join(traceDir, name) });
+      result.entries.push({ name, path: toFilePathUrl(import_path.default.join(traceDir, name)) });
   }
   const resourcesDir = import_path.default.join(traceDir, "resources");
   if (import_fs.default.existsSync(resourcesDir)) {
     for (const name of import_fs.default.readdirSync(resourcesDir))
-      result.entries.push({ name: "resources/" + name, path: import_path.default.join(resourcesDir, name) });
+      result.entries.push({ name: "resources/" + name, path: toFilePathUrl(import_path.default.join(resourcesDir, name)) });
   }
   return result;
 }
+function toFilePathUrl(filePath) {
+  return `file?path=${encodeURIComponent(filePath)}`;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   installRootRedirect,

package/lib/server/utils/expectUtils.js

@@ -18,10 +18,16 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var expectUtils_exports = {};
 __export(expectUtils_exports, {
-  serializeExpectedTextValues: () => serializeExpectedTextValues
+  callLogText: () => callLogText,
+  formatMatcherMessage: () => formatMatcherMessage,
+  printReceivedStringContainExpectedResult: () => printReceivedStringContainExpectedResult,
+  printReceivedStringContainExpectedSubstring: () => printReceivedStringContainExpectedSubstring,
+  serializeExpectedTextValues: () => serializeExpectedTextValues,
+  simpleMatcherUtils: () => simpleMatcherUtils
 });
 module.exports = __toCommonJS(expectUtils_exports);
 var import_rtti = require("../../utils/isomorphic/rtti");
+var import_utilsBundle = require("../../utilsBundle");
 function serializeExpectedTextValues(items, options = {}) {
   return items.map((i) => ({
     string: (0, import_rtti.isString)(i) ? i : void 0,
@@ -32,7 +38,86 @@ function serializeExpectedTextValues(items, options = {}) {
     normalizeWhiteSpace: options.normalizeWhiteSpace
   }));
 }
+const printSubstring = (val) => val.replace(/"|\\/g, "\\$&");
+const printReceivedStringContainExpectedSubstring = (utils, received, start, length) => utils.RECEIVED_COLOR(
+  '"' + printSubstring(received.slice(0, start)) + utils.INVERTED_COLOR(printSubstring(received.slice(start, start + length))) + printSubstring(received.slice(start + length)) + '"'
+);
+const printReceivedStringContainExpectedResult = (utils, received, result) => result === null ? utils.printReceived(received) : printReceivedStringContainExpectedSubstring(
+  utils,
+  received,
+  result.index,
+  result[0].length
+);
+function formatMatcherMessage(utils, details) {
+  const receiver = details.receiver ?? (details.locator ? "locator" : "page");
+  let message = utils.DIM_COLOR("expect(") + utils.RECEIVED_COLOR(receiver) + utils.DIM_COLOR(")" + (details.promise ? "." + details.promise : "") + (details.isNot ? ".not" : "") + ".") + details.matcherName + utils.DIM_COLOR("(") + utils.EXPECTED_COLOR(details.expectation) + utils.DIM_COLOR(")") + " failed\n\n";
+  const diffLines = details.printedDiff?.split("\n");
+  if (diffLines?.length === 2) {
+    details.printedExpected = diffLines[0];
+    details.printedReceived = diffLines[1];
+    details.printedDiff = void 0;
+  }
+  const align = !details.errorMessage && details.printedExpected?.startsWith("Expected:") && (!details.printedReceived || details.printedReceived.startsWith("Received:"));
+  if (details.locator)
+    message += `Locator: ${align ? " " : ""}${details.locator}
+`;
+  if (details.printedExpected)
+    message += details.printedExpected + "\n";
+  if (details.printedReceived)
+    message += details.printedReceived + "\n";
+  if (details.timedOut && details.timeout)
+    message += `Timeout: ${align ? " " : ""}${details.timeout}ms
+`;
+  if (details.printedDiff)
+    message += details.printedDiff + "\n";
+  if (details.errorMessage) {
+    message += details.errorMessage;
+    if (!details.errorMessage.endsWith("\n"))
+      message += "\n";
+  }
+  message += callLogText(utils, details.log);
+  return message;
+}
+const callLogText = (utils, log) => {
+  if (!log || !log.some((l) => !!l))
+    return "";
+  return `
+Call log:
+${utils.DIM_COLOR(log.join("\n"))}
+`;
+};
+function printValue(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function printReceived(value) {
+  return import_utilsBundle.colors.red(printValue(value));
+}
+function printExpected(value) {
+  return import_utilsBundle.colors.green(printValue(value));
+}
+const simpleMatcherUtils = {
+  DIM_COLOR: import_utilsBundle.colors.dim,
+  RECEIVED_COLOR: import_utilsBundle.colors.red,
+  EXPECTED_COLOR: import_utilsBundle.colors.green,
+  INVERTED_COLOR: import_utilsBundle.colors.inverse,
+  printReceived,
+  printExpected,
+  printDiffOrStringify: (expected, received, expectedLabel, receivedLabel) => {
+    const maxLength = Math.max(expectedLabel.length, receivedLabel.length) + 2;
+    return `${expectedLabel}: `.padEnd(maxLength) + printExpected(expected) + `
+` + `${receivedLabel}: `.padEnd(maxLength) + printReceived(received);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  serializeExpectedTextValues
+  callLogText,
+  formatMatcherMessage,
+  printReceivedStringContainExpectedResult,
+  printReceivedStringContainExpectedSubstring,
+  serializeExpectedTextValues,
+  simpleMatcherUtils
 });

package/lib/server/utils/hostPlatform.js

@@ -28,11 +28,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var hostPlatform_exports = {};
 __export(hostPlatform_exports, {
+  hasGpuMac: () => hasGpuMac,
   hostPlatform: () => hostPlatform,
   isOfficiallySupportedPlatform: () => isOfficiallySupportedPlatform,
   shortPlatform: () => shortPlatform
 });
 module.exports = __toCommonJS(hostPlatform_exports);
+var import_child_process = require("child_process");
 var import_os = __toESM(require("os"));
 var import_linuxUtils = require("./linuxUtils");
 function calculatePlatform() {
@@ -115,8 +117,21 @@ function toShortPlatform(hostPlatform2) {
   return hostPlatform2.endsWith("arm64") ? "linux-arm64" : "linux-x64";
 }
 const shortPlatform = toShortPlatform(hostPlatform);
+let hasGpuMacValue;
+function hasGpuMac() {
+  try {
+    if (hasGpuMacValue === void 0) {
+      const output = (0, import_child_process.execSync)("system_profiler SPDisplaysDataType", { stdio: ["ignore", "pipe", "ignore"] }).toString();
+      hasGpuMacValue = output.includes("Metal: Supported") || output.includes("Metal Support: Metal");
+    }
+    return hasGpuMacValue;
+  } catch (e) {
+    return false;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  hasGpuMac,
   hostPlatform,
   isOfficiallySupportedPlatform,
   shortPlatform

package/lib/server/utils/httpServer.js

@@ -36,7 +36,6 @@ var import_path = __toESM(require("path"));
 var import_utilsBundle = require("../../utilsBundle");
 var import_crypto = require("./crypto");
 var import_assert = require("../../utils/isomorphic/assert");
-var import_manualPromise = require("../../utils/isomorphic/manualPromise");
 var import_network = require("./network");
 class HttpServer {
   constructor() {
@@ -59,20 +58,6 @@ class HttpServer {
   port() {
     return this._port;
   }
-  async _tryStart(port, host) {
-    const errorPromise = new import_manualPromise.ManualPromise();
-    const errorListener = (error) => errorPromise.reject(error);
-    this._server.on("error", errorListener);
-    try {
-      this._server.listen(port, host);
-      await Promise.race([
-        new Promise((cb) => this._server.once("listening", cb)),
-        errorPromise
-      ]);
-    } finally {
-      this._server.removeListener("error", errorListener);
-    }
-  }
   createWebSocket(transport, guid) {
     (0, import_assert.assert)(!this._wsGuid, "can only create one main websocket transport per server");
     this._wsGuid = guid || (0, import_crypto.createGuid)();
@@ -100,17 +85,17 @@ class HttpServer {
   async start(options = {}) {
     (0, import_assert.assert)(!this._started, "server already started");
     this._started = true;
-    const host = options.host || "localhost";
+    const host = options.host;
     if (options.preferredPort) {
       try {
-        await this._tryStart(options.preferredPort, host);
+        await (0, import_network.startHttpServer)(this._server, { port: options.preferredPort, host });
       } catch (e) {
         if (!e || !e.message || !e.message.includes("EADDRINUSE"))
           throw e;
-        await this._tryStart(void 0, host);
+        await (0, import_network.startHttpServer)(this._server, { host });
       }
     } else {
-      await this._tryStart(options.port, host);
+      await (0, import_network.startHttpServer)(this._server, { port: options.port, host });
     }
     const address = this._server.address();
     (0, import_assert.assert)(address, "Could not bind server socket");
@@ -121,7 +106,7 @@ class HttpServer {
       this._port = address.port;
       const resolvedHost = address.family === "IPv4" ? address.address : `[${address.address}]`;
       this._urlPrefixPrecise = `http://${resolvedHost}:${address.port}`;
-      this._urlPrefixHumanReadable = `http://${host}:${address.port}`;
+      this._urlPrefixHumanReadable = `http://${host ?? "localhost"}:${address.port}`;
     }
   }
   async stop() {

package/lib/server/utils/network.js

@@ -35,22 +35,20 @@ __export(network_exports, {
   createProxyAgent: () => createProxyAgent,
   fetchData: () => fetchData,
   httpRequest: () => httpRequest,
-  isURLAvailable: () => isURLAvailable
+  isURLAvailable: () => isURLAvailable,
+  startHttpServer: () => startHttpServer
 });
 module.exports = __toCommonJS(network_exports);
 var import_http = __toESM(require("http"));
 var import_http2 = __toESM(require("http2"));
 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);
-  let options = {
-    ...parsedUrl,
-    agent: parsedUrl.protocol === "https:" ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent,
+  let url = new URL(params.url);
+  const options = {
     method: params.method || "GET",
     headers: params.headers
   };
@@ -58,21 +56,16 @@ function httpRequest(params, onResponse, onError) {
     options.rejectUnauthorized = params.rejectUnauthorized;
   const proxyURL = (0, import_utilsBundle.getProxyForUrl)(params.url);
   if (proxyURL) {
+    const parsedProxyURL = normalizeProxyURL(proxyURL);
     if (params.url.startsWith("http:")) {
-      const parsedProxyURL = import_url.default.parse(proxyURL);
-      options = {
-        path: parsedUrl.href,
-        host: parsedProxyURL.hostname,
-        port: parsedProxyURL.port,
-        protocol: parsedProxyURL.protocol || "http:",
-        headers: options.headers,
-        method: options.method
-      };
+      parsedProxyURL.pathname = url.toString();
+      url = parsedProxyURL;
     } else {
-      options.agent = new import_utilsBundle.HttpsProxyAgent(normalizeProxyURL(proxyURL));
+      options.agent = new import_utilsBundle.HttpsProxyAgent(parsedProxyURL);
       options.rejectUnauthorized = false;
     }
   }
+  options.agent ??= url.protocol === "https:" ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent;
   let cancelRequest;
   const requestCallback = (res) => {
     const statusCode = res.statusCode || 0;
@@ -83,7 +76,7 @@ function httpRequest(params, onResponse, onError) {
       onResponse(res);
     }
   };
-  const request = options.protocol === "https:" ? import_https.default.request(options, requestCallback) : import_http.default.request(options, requestCallback);
+  const request = url.protocol === "https:" ? import_https.default.request(url, options, requestCallback) : import_http.default.request(url, options, requestCallback);
   request.on("error", onError);
   if (params.socketTimeout !== void 0) {
     request.setTimeout(params.socketTimeout, () => {
@@ -122,7 +115,7 @@ async function fetchData(progress, params, onError) {
     throw error;
   }
 }
-function shouldBypassProxy(url2, bypass) {
+function shouldBypassProxy(url, bypass) {
   if (!bypass)
     return false;
   const domains = bypass.split(",").map((s) => {
@@ -131,7 +124,7 @@ function shouldBypassProxy(url2, bypass) {
       s = "." + s;
     return s;
   });
-  const domain = "." + url2.hostname;
+  const domain = "." + url.hostname;
   return domains.some((d) => domain.endsWith(d));
 }
 function normalizeProxyURL(proxy) {
@@ -177,20 +170,35 @@ function createHttp2Server(...args) {
   decorateServer(server);
   return server;
 }
-async function isURLAvailable(url2, ignoreHTTPSErrors, onLog, onStdErr) {
-  let statusCode = await httpStatusCode(url2, ignoreHTTPSErrors, onLog, onStdErr);
-  if (statusCode === 404 && url2.pathname === "/") {
-    const indexUrl = new URL(url2);
+async function startHttpServer(server, options) {
+  const { host = "localhost", port = 0 } = options;
+  const errorPromise = new import_manualPromise.ManualPromise();
+  const errorListener = (error) => errorPromise.reject(error);
+  server.on("error", errorListener);
+  try {
+    server.listen(port, host);
+    await Promise.race([
+      new Promise((cb) => server.once("listening", cb)),
+      errorPromise
+    ]);
+  } finally {
+    server.removeListener("error", errorListener);
+  }
+}
+async function isURLAvailable(url, ignoreHTTPSErrors, onLog, onStdErr) {
+  let statusCode = await httpStatusCode(url, ignoreHTTPSErrors, onLog, onStdErr);
+  if (statusCode === 404 && url.pathname === "/") {
+    const indexUrl = new URL(url);
     indexUrl.pathname = "/index.html";
     statusCode = await httpStatusCode(indexUrl, ignoreHTTPSErrors, onLog, onStdErr);
   }
   return statusCode >= 200 && statusCode < 404;
 }
-async function httpStatusCode(url2, ignoreHTTPSErrors, onLog, onStdErr) {
+async function httpStatusCode(url, ignoreHTTPSErrors, onLog, onStdErr) {
   return new Promise((resolve) => {
-    onLog?.(`HTTP GET: ${url2}`);
+    onLog?.(`HTTP GET: ${url}`);
     httpRequest({
-      url: url2.toString(),
+      url: url.toString(),
       headers: { Accept: "*/*" },
       rejectUnauthorized: !ignoreHTTPSErrors
     }, (res) => {
@@ -201,7 +209,7 @@ async function httpStatusCode(url2, ignoreHTTPSErrors, onLog, onStdErr) {
     }, (error) => {
       if (error.code === "DEPTH_ZERO_SELF_SIGNED_CERT")
         onStdErr?.(`[WebServer] Self-signed certificate detected. Try adding ignoreHTTPSErrors: true to config.webServer.`);
-      onLog?.(`Error while checking if ${url2} is available: ${error.message}`);
+      onLog?.(`Error while checking if ${url} is available: ${error.message}`);
       resolve(0);
     });
   });
@@ -229,5 +237,6 @@ function decorateServer(server) {
   createProxyAgent,
   fetchData,
   httpRequest,
-  isURLAvailable
+  isURLAvailable,
+  startHttpServer
 });

package/lib/server/utils/nodePlatform.js

@@ -42,6 +42,7 @@ var import_utilsBundle = require("../../utilsBundle");
 var import_debugLogger = require("./debugLogger");
 var import_zones = require("./zones");
 var import_debug = require("./debug");
+var import_mcpBundle = require("../../mcpBundle");
 const pipelineAsync = util.promisify(import_stream.pipeline);
 class NodeZone {
   constructor(zone) {
@@ -105,6 +106,11 @@ const nodePlatform = {
   streamWritable: (channel) => {
     return new WritableStreamImpl(channel);
   },
+  zodToJsonSchema: (schema) => {
+    if ("_zod" in schema)
+      return import_mcpBundle.z.toJSONSchema(schema);
+    return (0, import_mcpBundle.zodToJsonSchema)(schema);
+  },
   zones: {
     current: () => new NodeZone((0, import_zones.currentZone)()),
     empty: new NodeZone(import_zones.emptyZone)

package/lib/server/{chromium/videoRecorder.js → videoRecorder.js}

@@ -21,12 +21,11 @@ __export(videoRecorder_exports, {
   VideoRecorder: () => VideoRecorder
 });
 module.exports = __toCommonJS(videoRecorder_exports);
-var import_utils = require("../../utils");
-var import_page = require("../page");
-var import_processLauncher = require("../utils/processLauncher");
+var import_utils = require("../utils");
+var import_processLauncher = require("./utils/processLauncher");
 const fps = 25;
 class VideoRecorder {
-  constructor(page, ffmpegPath) {
+  constructor(ffmpegPath, options) {
     this._process = null;
     this._gracefullyClose = null;
     this._lastWritePromise = Promise.resolve();
@@ -36,16 +35,12 @@ class VideoRecorder {
     this._frameQueue = [];
     this._isStopped = false;
     this._ffmpegPath = ffmpegPath;
-    page.on(import_page.Page.Events.ScreencastFrame, (frame) => this.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3));
-  }
-  static async launch(page, ffmpegPath, options) {
     if (!options.outputFile.endsWith(".webm"))
       throw new Error("File must have .webm extension");
-    const recorder = new VideoRecorder(page, ffmpegPath);
-    await recorder._launch(options);
-    return recorder;
+    this._launchPromise = this._launch(options).catch((e) => e);
   }
   async _launch(options) {
+    await (0, import_utils.mkdirIfNeeded)(options.outputFile);
     const w = options.width;
     const h = options.height;
     const args = `-loglevel error -f image2pipe -avioflags direct -fpsprobesize 0 -probesize 32 -analyzeduration 0 -c:v mjpeg -i pipe:0 -y -an -r ${fps} -c:v vp8 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1 -vf pad=${w}:${h}:0:0:gray,crop=${w}:${h}:0:0`.split(" ");
@@ -74,6 +69,13 @@ class VideoRecorder {
     this._gracefullyClose = gracefullyClose;
   }
   writeFrame(frame, timestamp) {
+    this._launchPromise.then((error) => {
+      if (error)
+        return;
+      this._writeFrame(frame, timestamp);
+    });
+  }
+  _writeFrame(frame, timestamp) {
     (0, import_utils.assert)(this._process);
     if (this._isStopped)
       return;
@@ -100,13 +102,20 @@ class VideoRecorder {
     });
   }
   async stop() {
+    const error = await this._launchPromise;
+    if (error)
+      throw error;
     if (this._isStopped || !this._lastFrame)
       return;
     const addTime = Math.max(((0, import_utils.monotonicTime)() - this._lastWriteNodeTime) / 1e3, 1);
-    this.writeFrame(Buffer.from([]), this._lastFrame.timestamp + addTime);
+    this._writeFrame(Buffer.from([]), this._lastFrame.timestamp + addTime);
     this._isStopped = true;
-    await this._lastWritePromise;
-    await this._gracefullyClose();
+    try {
+      await this._lastWritePromise;
+      await this._gracefullyClose();
+    } catch (e) {
+      import_utils.debugLogger.log("error", `ffmpeg failed to stop: ${String(e)}`);
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/webkit/webkit.js

@@ -51,12 +51,10 @@ class WebKit extends import_browserType.BrowserType {
       CURL_COOKIE_JAR_PATH: process.platform === "win32" && isPersistent ? import_path.default.join(userDataDir, "cookiejar.db") : void 0
     };
   }
-  doRewriteStartupLog(error) {
-    if (!error.logs)
-      return error;
-    if (error.logs.includes("Failed to open display") || error.logs.includes("cannot open display"))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
-    return error;
+  doRewriteStartupLog(logs) {
+    if (logs.includes("Failed to open display") || logs.includes("cannot open display"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    return logs;
   }
   attemptToGracefullyCloseBrowser(transport) {
     transport.send({ method: "Playwright.close", params: {}, id: import_wkConnection.kBrowserCloseMessageId });

package/lib/server/webkit/wkBrowser.js

@@ -56,7 +56,6 @@ class WKBrowser extends import_browser.Browser {
     this._browserSession.on("Playwright.downloadCreated", this._onDownloadCreated.bind(this));
     this._browserSession.on("Playwright.downloadFilenameSuggested", this._onDownloadFilenameSuggested.bind(this));
     this._browserSession.on("Playwright.downloadFinished", this._onDownloadFinished.bind(this));
-    this._browserSession.on("Playwright.screencastFinished", this._onScreencastFinished.bind(this));
     this._browserSession.on(import_wkConnection.kPageProxyMessageReceived, this._onPageProxyMessageReceived.bind(this));
   }
   static async connect(parent, transport, options) {
@@ -79,7 +78,7 @@ class WKBrowser extends import_browser.Browser {
       wkPage.didClose();
     this._wkPages.clear();
     for (const video of this._idToVideo.values())
-      video.artifact.reportFinished(new import_errors.TargetClosedError());
+      video.artifact.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
     this._idToVideo.clear();
     this._didClose();
   }
@@ -131,9 +130,6 @@ class WKBrowser extends import_browser.Browser {
   _onDownloadFinished(payload) {
     this._downloadFinished(payload.uuid, payload.error);
   }
-  _onScreencastFinished(payload) {
-    this._takeVideo(payload.screencastId)?.reportFinished();
-  }
   _onPageProxyCreated(event) {
     const pageProxyId = event.pageProxyId;
     let context = null;
@@ -315,7 +311,7 @@ class WKBrowserContext extends import_browserContext.BrowserContext {
   }
   async doClose(reason) {
     if (!this._browserContextId) {
-      await Promise.all(this._wkPages().map((wkPage) => wkPage._stopVideo()));
+      await Promise.all(this._wkPages().map((wkPage) => wkPage._page.screencast.stopVideoRecording()));
       await this._browser.close({ reason });
     } else {
       await this._browser._browserSession.send("Playwright.deleteContext", { browserContextId: this._browserContextId });

package/lib/server/webkit/wkConnection.js

@@ -89,11 +89,6 @@ class WKSession extends import_events.EventEmitter {
     this.connection = connection;
     this.sessionId = sessionId;
     this._rawSend = rawSend;
-    this.on = super.on;
-    this.off = super.removeListener;
-    this.addListener = super.addListener;
-    this.removeListener = super.removeListener;
-    this.once = super.once;
   }
   async send(method, params) {
     if (this._crashed || this._disposed || this.connection._browserDisconnectedLogs)
@@ -134,7 +129,7 @@ class WKSession extends import_events.EventEmitter {
         callback.resolve(object.result);
       }
     } else if (object.id && !object.error) {
-      (0, import_utils.assert)(this.isDisposed());
+      (0, import_utils.assert)(this.isDisposed(), JSON.stringify(object));
     } else {
       Promise.resolve().then(() => this.emit(object.method, object.params));
     }

package/lib/server/webkit/wkInterceptableRequest.js

@@ -54,7 +54,7 @@ class WKInterceptableRequest {
   constructor(session, frame, event, redirectedFrom, documentId) {
     this._session = session;
     this._requestId = event.requestId;
-    const resourceType = event.type ? event.type.toLowerCase() : redirectedFrom ? redirectedFrom.request.resourceType() : "other";
+    const resourceType = event.type ? toResourceType(event.type) : redirectedFrom ? redirectedFrom.request.resourceType() : "other";
     let postDataBuffer = null;
     this._timestamp = event.timestamp;
     this._wallTime = event.walltime * 1e3;
@@ -162,6 +162,34 @@ function wkMillisToRoundishMillis(value) {
   }
   return (value * 1e3 | 0) / 1e3;
 }
+function toResourceType(type) {
+  switch (type) {
+    case "Document":
+      return "document";
+    case "StyleSheet":
+      return "stylesheet";
+    case "Image":
+      return "image";
+    case "Font":
+      return "font";
+    case "Script":
+      return "script";
+    case "XHR":
+      return "xhr";
+    case "Fetch":
+      return "fetch";
+    case "Ping":
+      return "ping";
+    case "Beacon":
+      return "beacon";
+    case "WebSocket":
+      return "websocket";
+    case "EventSource":
+      return "eventsource";
+    default:
+      return "other";
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   WKInterceptableRequest,