patchright-core 1.52.4 → 1.55.0

package/lib/server/socksClientCertificatesInterceptor.js

@@ -44,6 +44,7 @@ var import_browserContext = require("./browserContext");
 var import_network = require("./utils/network");
 var import_debugLogger = require("./utils/debugLogger");
 var import_happyEyeballs = require("./utils/happyEyeballs");
+var import_utilsBundle = require("../utilsBundle");
 let dummyServerTlsOptions = void 0;
 function loadDummyServerCertsIfNeeded() {
   if (dummyServerTlsOptions)
@@ -51,168 +52,150 @@ function loadDummyServerCertsIfNeeded() {
   const { cert, key } = (0, import_utils.generateSelfSignedCertificate)();
   dummyServerTlsOptions = { key, cert };
 }
-class ALPNCache {
-  constructor() {
-    this._cache = /* @__PURE__ */ new Map();
-  }
-  get(host, port, success) {
-    const cacheKey = `${host}:${port}`;
-    {
-      const result2 = this._cache.get(cacheKey);
-      if (result2) {
-        result2.then(success);
-        return;
-      }
-    }
-    const result = new import_utils.ManualPromise();
-    this._cache.set(cacheKey, result);
-    result.then(success);
-    (0, import_happyEyeballs.createTLSSocket)({
-      host,
-      port,
-      servername: import_net.default.isIP(host) ? void 0 : host,
-      ALPNProtocols: ["h2", "http/1.1"],
-      rejectUnauthorized: false
-    }).then((socket) => {
-      result.resolve(socket.alpnProtocol || "http/1.1");
-      socket.end();
-    }).catch((error) => {
-      import_debugLogger.debugLogger.log("client-certificates", `ALPN error: ${error.message}`);
-      result.resolve("http/1.1");
-    });
-  }
-}
 class SocksProxyConnection {
   constructor(socksProxy, uid, host, port) {
-    this.firstPackageReceived = false;
+    this._firstPackageReceived = false;
     this._closed = false;
     this.socksProxy = socksProxy;
     this.uid = uid;
     this.host = host;
     this.port = port;
-    this._targetCloseEventListener = () => {
-      this.socksProxy._socksProxy.sendSocketEnd({ uid: this.uid });
-      this.internalTLS?.destroy();
-      this._dummyServer?.close();
+    this._serverCloseEventListener = () => {
+      this._browserEncrypted.destroy();
     };
+    this._browserEncrypted = new import_stream.default.Duplex({
+      read: () => {
+      },
+      write: (data, encoding, callback) => {
+        this.socksProxy._socksProxy.sendSocketData({ uid: this.uid, data });
+        callback();
+      },
+      destroy: (error, callback) => {
+        if (error)
+          socksProxy._socksProxy.sendSocketError({ uid: this.uid, error: error.message });
+        else
+          socksProxy._socksProxy.sendSocketEnd({ uid: this.uid });
+        callback();
+      }
+    });
   }
   async connect() {
-    if (this.socksProxy.proxyAgentFromOptions)
-      this.target = await this.socksProxy.proxyAgentFromOptions.callback(new import_events.EventEmitter(), { host: rewriteToLocalhostIfNeeded(this.host), port: this.port, secureEndpoint: false });
+    const proxyAgent = this.socksProxy.getProxyAgent(this.host, this.port);
+    if (proxyAgent)
+      this._serverEncrypted = await proxyAgent.callback(new import_events.EventEmitter(), { host: rewriteToLocalhostIfNeeded(this.host), port: this.port, secureEndpoint: false });
     else
-      this.target = await (0, import_happyEyeballs.createSocket)(rewriteToLocalhostIfNeeded(this.host), this.port);
-    this.target.once("close", this._targetCloseEventListener);
-    this.target.once("error", (error) => this.socksProxy._socksProxy.sendSocketError({ uid: this.uid, error: error.message }));
+      this._serverEncrypted = await (0, import_happyEyeballs.createSocket)(rewriteToLocalhostIfNeeded(this.host), this.port);
+    this._serverEncrypted.once("close", this._serverCloseEventListener);
+    this._serverEncrypted.once("error", (error) => this._browserEncrypted.destroy(error));
     if (this._closed) {
-      this.target.destroy();
+      this._serverEncrypted.destroy();
       return;
     }
     this.socksProxy._socksProxy.socketConnected({
       uid: this.uid,
-      host: this.target.localAddress,
-      port: this.target.localPort
+      host: this._serverEncrypted.localAddress,
+      port: this._serverEncrypted.localPort
     });
   }
   onClose() {
-    this.target.destroy();
-    this.internalTLS?.destroy();
-    this._dummyServer?.close();
+    this._serverEncrypted.destroy();
+    this._browserEncrypted.destroy();
     this._closed = true;
   }
   onData(data) {
-    if (!this.firstPackageReceived) {
-      this.firstPackageReceived = true;
+    if (!this._firstPackageReceived) {
+      this._firstPackageReceived = true;
       if (data[0] === 22)
-        this._attachTLSListeners();
+        this._establishTlsTunnel(this._browserEncrypted, data);
       else
-        this.target.on("data", (data2) => this.socksProxy._socksProxy.sendSocketData({ uid: this.uid, data: data2 }));
+        this._establishPlaintextTunnel(this._browserEncrypted);
     }
-    if (this.internal)
-      this.internal.push(data);
-    else
-      this.target.write(data);
+    this._browserEncrypted.push(data);
   }
-  _attachTLSListeners() {
-    this.internal = new import_stream.default.Duplex({
-      read: () => {
-      },
-      write: (data, encoding, callback) => {
-        this.socksProxy._socksProxy.sendSocketData({ uid: this.uid, data });
-        callback();
+  _establishPlaintextTunnel(browserEncrypted) {
+    browserEncrypted.pipe(this._serverEncrypted);
+    this._serverEncrypted.pipe(browserEncrypted);
+  }
+  _establishTlsTunnel(browserEncrypted, clientHello) {
+    const browserALPNProtocols = parseALPNFromClientHello(clientHello) || ["http/1.1"];
+    import_debugLogger.debugLogger.log("client-certificates", `Browser->Proxy ${this.host}:${this.port} offers ALPN ${browserALPNProtocols}`);
+    const serverDecrypted = import_tls.default.connect({
+      socket: this._serverEncrypted,
+      host: this.host,
+      port: this.port,
+      rejectUnauthorized: !this.socksProxy.ignoreHTTPSErrors,
+      ALPNProtocols: browserALPNProtocols,
+      servername: !import_net.default.isIP(this.host) ? this.host : void 0,
+      secureContext: this.socksProxy.secureContextMap.get(new URL(`https://${this.host}:${this.port}`).origin)
+    }, async () => {
+      const browserDecrypted = await this._upgradeToTLSIfNeeded(browserEncrypted, serverDecrypted.alpnProtocol);
+      import_debugLogger.debugLogger.log("client-certificates", `Proxy->Server ${this.host}:${this.port} chooses ALPN ${browserDecrypted.alpnProtocol}`);
+      browserDecrypted.pipe(serverDecrypted);
+      serverDecrypted.pipe(browserDecrypted);
+      const cleanup = (error) => this._serverEncrypted.destroy(error);
+      browserDecrypted.once("error", cleanup);
+      serverDecrypted.once("error", cleanup);
+      browserDecrypted.once("close", cleanup);
+      serverDecrypted.once("close", cleanup);
+      if (this._closed)
+        serverDecrypted.destroy();
+    });
+    serverDecrypted.once("error", async (error) => {
+      import_debugLogger.debugLogger.log("client-certificates", `error when connecting to server: ${error.message.replaceAll("\n", " ")}`);
+      this._serverEncrypted.removeListener("close", this._serverCloseEventListener);
+      this._serverEncrypted.destroy();
+      const browserDecrypted = await this._upgradeToTLSIfNeeded(this._browserEncrypted, serverDecrypted.alpnProtocol);
+      const responseBody = (0, import_utils.escapeHTML)("Playwright client-certificate error: " + error.message).replaceAll("\n", " <br>");
+      if (browserDecrypted.alpnProtocol === "h2") {
+        if ("performServerHandshake" in import_http2.default) {
+          const session = import_http2.default.performServerHandshake(browserDecrypted);
+          session.on("error", (error2) => {
+            this._browserEncrypted.destroy(error2);
+          });
+          session.once("stream", (stream2) => {
+            const cleanup = (error2) => {
+              session.close();
+              this._browserEncrypted.destroy(error2);
+            };
+            stream2.once("end", cleanup);
+            stream2.once("error", cleanup);
+            stream2.respond({
+              [import_http2.default.constants.HTTP2_HEADER_CONTENT_TYPE]: "text/html",
+              [import_http2.default.constants.HTTP2_HEADER_STATUS]: 503
+            });
+            stream2.end(responseBody);
+          });
+        } else {
+          this._browserEncrypted.destroy(error);
+        }
+      } else {
+        browserDecrypted.end([
+          "HTTP/1.1 503 Internal Server Error",
+          "Content-Type: text/html; charset=utf-8",
+          "Content-Length: " + Buffer.byteLength(responseBody),
+          "",
+          responseBody
+        ].join("\r\n"));
       }
     });
-    this.socksProxy.alpnCache.get(rewriteToLocalhostIfNeeded(this.host), this.port, (alpnProtocolChosenByServer) => {
-      import_debugLogger.debugLogger.log("client-certificates", `Proxy->Target ${this.host}:${this.port} chooses ALPN ${alpnProtocolChosenByServer}`);
-      if (this._closed)
-        return;
-      this._dummyServer = import_tls.default.createServer({
+  }
+  async _upgradeToTLSIfNeeded(socket, alpnProtocol) {
+    this._brorwserDecrypted ??= new Promise((resolve, reject) => {
+      const dummyServer = import_tls.default.createServer({
         ...dummyServerTlsOptions,
-        ALPNProtocols: alpnProtocolChosenByServer === "h2" ? ["h2", "http/1.1"] : ["http/1.1"]
+        ALPNProtocols: [alpnProtocol || "http/1.1"]
       });
-      this._dummyServer.emit("connection", this.internal);
-      this._dummyServer.once("secureConnection", (internalTLS) => {
-        this.internalTLS = internalTLS;
-        import_debugLogger.debugLogger.log("client-certificates", `Browser->Proxy ${this.host}:${this.port} chooses ALPN ${internalTLS.alpnProtocol}`);
-        let targetTLS = void 0;
-        const handleError = (error) => {
-          import_debugLogger.debugLogger.log("client-certificates", `error when connecting to target: ${error.message.replaceAll("\n", " ")}`);
-          const responseBody = (0, import_utils.escapeHTML)("Playwright client-certificate error: " + error.message).replaceAll("\n", " <br>");
-          if (internalTLS?.alpnProtocol === "h2") {
-            if ("performServerHandshake" in import_http2.default) {
-              this.target.removeListener("close", this._targetCloseEventListener);
-              const session = import_http2.default.performServerHandshake(internalTLS);
-              session.on("error", () => {
-                this.target.destroy();
-                this._targetCloseEventListener();
-              });
-              session.once("stream", (stream2) => {
-                stream2.respond({
-                  "content-type": "text/html",
-                  [import_http2.default.constants.HTTP2_HEADER_STATUS]: 503
-                });
-                const cleanup = () => {
-                  session.close();
-                  this.target.destroy();
-                  this._targetCloseEventListener();
-                };
-                stream2.end(responseBody, cleanup);
-                stream2.once("error", cleanup);
-              });
-            } else {
-              this.target.destroy();
-            }
-          } else {
-            internalTLS.end([
-              "HTTP/1.1 503 Internal Server Error",
-              "Content-Type: text/html; charset=utf-8",
-              "Content-Length: " + Buffer.byteLength(responseBody),
-              "",
-              responseBody
-            ].join("\r\n"));
-            this.target.destroy();
-          }
-        };
-        if (this._closed) {
-          internalTLS.destroy();
-          return;
-        }
-        targetTLS = import_tls.default.connect({
-          socket: this.target,
-          host: this.host,
-          port: this.port,
-          rejectUnauthorized: !this.socksProxy.ignoreHTTPSErrors,
-          ALPNProtocols: [internalTLS.alpnProtocol || "http/1.1"],
-          servername: !import_net.default.isIP(this.host) ? this.host : void 0,
-          secureContext: this.socksProxy.secureContextMap.get(new URL(`https://${this.host}:${this.port}`).origin)
-        });
-        targetTLS.once("secureConnect", () => {
-          internalTLS.pipe(targetTLS);
-          targetTLS.pipe(internalTLS);
-        });
-        internalTLS.once("error", () => this.target.destroy());
-        targetTLS.once("error", handleError);
+      dummyServer.emit("connection", socket);
+      dummyServer.once("secureConnection", (tlsSocket) => {
+        dummyServer.close();
+        resolve(tlsSocket);
+      });
+      dummyServer.once("error", (error) => {
+        dummyServer.close();
+        reject(error);
       });
     });
+    return this._brorwserDecrypted;
   }
 }
 class ClientCertificatesProxy {
@@ -220,9 +203,8 @@ class ClientCertificatesProxy {
     this._connections = /* @__PURE__ */ new Map();
     this.secureContextMap = /* @__PURE__ */ new Map();
     (0, import_browserContext.verifyClientCertificates)(contextOptions.clientCertificates);
-    this.alpnCache = new ALPNCache();
     this.ignoreHTTPSErrors = contextOptions.ignoreHTTPSErrors;
-    this.proxyAgentFromOptions = (0, import_network.createProxyAgent)(contextOptions.proxy);
+    this._proxy = contextOptions.proxy;
     this._initSecureContexts(contextOptions.clientCertificates);
     this._socksProxy = new import_socksProxy.SocksProxy();
     this._socksProxy.setPattern("*");
@@ -232,10 +214,11 @@ class ClientCertificatesProxy {
         await connection.connect();
         this._connections.set(payload.uid, connection);
       } catch (error) {
+        import_debugLogger.debugLogger.log("client-certificates", `Failed to connect to ${payload.host}:${payload.port}: ${error.message}`);
         this._socksProxy.socketFailed({ uid: payload.uid, errorCode: error.code });
       }
     });
-    this._socksProxy.addListener(import_socksProxy.SocksProxy.Events.SocksData, async (payload) => {
+    this._socksProxy.addListener(import_socksProxy.SocksProxy.Events.SocksData, (payload) => {
       this._connections.get(payload.uid)?.onData(payload.data);
     });
     this._socksProxy.addListener(import_socksProxy.SocksProxy.Events.SocksClosed, (payload) => {
@@ -244,6 +227,14 @@ class ClientCertificatesProxy {
     });
     loadDummyServerCertsIfNeeded();
   }
+  getProxyAgent(host, port) {
+    const proxyFromOptions = (0, import_network.createProxyAgent)(this._proxy);
+    if (proxyFromOptions)
+      return proxyFromOptions;
+    const proxyFromEnv = (0, import_utilsBundle.getProxyForUrl)(`https://${host}:${port}`);
+    if (proxyFromEnv)
+      return (0, import_network.createProxyAgent)({ server: proxyFromEnv });
+  }
   _initSecureContexts(clientCertificates) {
     const origin2certs = /* @__PURE__ */ new Map();
     for (const cert of clientCertificates || []) {
@@ -261,9 +252,18 @@ class ClientCertificatesProxy {
       }
     }
   }
-  async listen() {
-    const port = await this._socksProxy.listen(0, "127.0.0.1");
-    return { server: `socks5://127.0.0.1:${port}` };
+  static async create(progress, contextOptions) {
+    const proxy = new ClientCertificatesProxy(contextOptions);
+    try {
+      await progress.race(proxy._socksProxy.listen(0, "127.0.0.1"));
+      return proxy;
+    } catch (error) {
+      await proxy.close();
+      throw error;
+    }
+  }
+  proxySettings() {
+    return { server: `socks5://127.0.0.1:${this._socksProxy.port()}` };
   }
   async close() {
     await this._socksProxy.close();
@@ -313,6 +313,68 @@ function rewriteOpenSSLErrorIfNeeded(error) {
     "You could probably modernize the certificate by following the steps at https://github.com/nodejs/node/issues/40672#issuecomment-1243648223"
   ].join("\n"));
 }
+function parseALPNFromClientHello(buffer) {
+  if (buffer.length < 6)
+    return null;
+  if (buffer[0] !== 22)
+    return null;
+  let offset = 5;
+  if (buffer[offset] !== 1)
+    return null;
+  offset += 4;
+  offset += 2;
+  offset += 32;
+  if (offset >= buffer.length)
+    return null;
+  const sessionIdLength = buffer[offset];
+  offset += 1 + sessionIdLength;
+  if (offset + 2 > buffer.length)
+    return null;
+  const cipherSuitesLength = buffer.readUInt16BE(offset);
+  offset += 2 + cipherSuitesLength;
+  if (offset >= buffer.length)
+    return null;
+  const compressionMethodsLength = buffer[offset];
+  offset += 1 + compressionMethodsLength;
+  if (offset + 2 > buffer.length)
+    return null;
+  const extensionsLength = buffer.readUInt16BE(offset);
+  offset += 2;
+  const extensionsEnd = offset + extensionsLength;
+  if (extensionsEnd > buffer.length)
+    return null;
+  while (offset + 4 <= extensionsEnd) {
+    const extensionType = buffer.readUInt16BE(offset);
+    offset += 2;
+    const extensionLength = buffer.readUInt16BE(offset);
+    offset += 2;
+    if (offset + extensionLength > extensionsEnd)
+      return null;
+    if (extensionType === 16)
+      return parseALPNExtension(buffer.subarray(offset, offset + extensionLength));
+    offset += extensionLength;
+  }
+  return null;
+}
+function parseALPNExtension(buffer) {
+  if (buffer.length < 2)
+    return null;
+  const listLength = buffer.readUInt16BE(0);
+  if (listLength !== buffer.length - 2)
+    return null;
+  const protocols = [];
+  let offset = 2;
+  while (offset < buffer.length) {
+    const protocolLength = buffer[offset];
+    offset += 1;
+    if (offset + protocolLength > buffer.length)
+      break;
+    const protocol = buffer.subarray(offset, offset + protocolLength).toString("utf8");
+    protocols.push(protocol);
+    offset += protocolLength;
+  }
+  return protocols.length > 0 ? protocols : null;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ClientCertificatesProxy,

package/lib/server/trace/recorder/snapshotter.js

@@ -32,7 +32,6 @@ var import_page = require("../../page");
 class Snapshotter {
   constructor(context, delegate) {
     this._eventListeners = [];
-    this._initialized = false;
     this._started = false;
     this._context = context;
     this._delegate = delegate;
@@ -44,21 +43,23 @@ class Snapshotter {
   }
   async start() {
     this._started = true;
-    if (!this._initialized) {
-      this._initialized = true;
+    if (!this._initScript)
       await this._initialize();
-    }
     await this.reset();
   }
   async reset() {
     if (this._started)
-      await this._runInAllFrames(`window["${this._snapshotStreamer}"].reset()`);
+      await this._context.safeNonStallingEvaluateInAllFrames(`window["${this._snapshotStreamer}"].reset()`, "main");
   }
-  async stop() {
+  stop() {
     this._started = false;
   }
-  resetForReuse() {
-    this._initialized = false;
+  async resetForReuse() {
+    if (this._initScript) {
+      import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
+      await this._context.removeInitScripts([this._initScript]);
+      this._initScript = void 0;
+    }
   }
   async _initialize() {
     for (const page of this._context.pages())
@@ -67,17 +68,9 @@ class Snapshotter {
       import_eventsHelper.eventsHelper.addEventListener(this._context, import_browserContext.BrowserContext.Events.Page, this._onPage.bind(this))
     ];
     const { javaScriptEnabled } = this._context._options;
-    const initScript = `(${import_snapshotterInjected.frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === void 0})`;
-    await this._context.addInitScript(initScript);
-    await this._runInAllFrames(initScript);
-  }
-  async _runInAllFrames(expression) {
-    const frames = [];
-    for (const page of this._context.pages())
-      frames.push(...page.frames());
-    await Promise.all(frames.map((frame) => {
-      return frame.nonStallingRawEvaluateInExistingMainContext(expression).catch((e) => import_debugLogger.debugLogger.log("error", e));
-    }));
+    const initScriptSource = `(${import_snapshotterInjected.frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === void 0})`;
+    this._initScript = await this._context.addInitScript(void 0, initScriptSource);
+    await this._context.safeNonStallingEvaluateInAllFrames(initScriptSource, "main");
   }
   dispose() {
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);

package/lib/server/trace/recorder/tracing.js

@@ -28,15 +28,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var tracing_exports = {};
 __export(tracing_exports, {
-  Tracing: () => Tracing,
-  shouldCaptureSnapshot: () => shouldCaptureSnapshot
+  Tracing: () => Tracing
 });
 module.exports = __toCommonJS(tracing_exports);
 var import_fs = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
 var import_snapshotter = require("./snapshotter");
-var import_debug = require("../../../protocol/debug");
+var import_protocolMetainfo = require("../../../utils/isomorphic/protocolMetainfo");
 var import_assert = require("../../../utils/isomorphic/assert");
 var import_time = require("../../../utils/isomorphic/time");
 var import_eventsHelper = require("../../utils/eventsHelper");
@@ -49,7 +48,8 @@ var import_fileUtils = require("../../utils/fileUtils");
 var import_harTracer = require("../../har/harTracer");
 var import_instrumentation = require("../../instrumentation");
 var import_page = require("../../page");
-const version = 7;
+var import_progress = require("../../progress");
+const version = 8;
 const kScreencastOptions = { width: 800, height: 600, quality: 90 };
 class Tracing extends import_instrumentation.SdkObject {
   constructor(context, tracesDir) {
@@ -78,7 +78,7 @@ class Tracing extends import_instrumentation.SdkObject {
       platform: process.platform,
       wallTime: 0,
       monotonicTime: 0,
-      sdkLanguage: context.attribution.playwright.options.sdkLanguage,
+      sdkLanguage: this._sdkLanguage(),
       testIdAttributeName,
       contextId: context.guid
     };
@@ -90,18 +90,22 @@ class Tracing extends import_instrumentation.SdkObject {
       this._contextCreatedEvent.options = context._options;
     }
   }
-  async resetForReuse() {
-    await this.stopChunk({ mode: "discard" }).catch(() => {
+  _sdkLanguage() {
+    return this._context instanceof import_browserContext.BrowserContext ? this._context._browser.sdkLanguage() : this._context.attribution.playwright.options.sdkLanguage;
+  }
+  async resetForReuse(progress) {
+    await this.stopChunk(progress, { mode: "discard" }).catch(() => {
     });
-    await this.stop();
-    this._snapshotter?.resetForReuse();
+    await this.stop(progress);
+    if (this._snapshotter)
+      await progress.race(this._snapshotter.resetForReuse());
   }
-  async start(options) {
+  start(options) {
     if (this._isStopping)
       throw new Error("Cannot start tracing while stopping");
     if (this._state)
       throw new Error("Tracing has been already started");
-    this._contextCreatedEvent.sdkLanguage = this._context.attribution.playwright.options.sdkLanguage;
+    this._contextCreatedEvent.sdkLanguage = this._sdkLanguage();
     const traceName = options.name || (0, import_crypto.createGuid)();
     const tracesDir = this._createTracesDirIfNeeded();
     this._state = {
@@ -123,9 +127,9 @@ class Tracing extends import_instrumentation.SdkObject {
     if (options.snapshots)
       this._harTracer.start({ omitScripts: !options.live });
   }
-  async startChunk(options = {}) {
+  async startChunk(progress, options = {}) {
     if (this._state && this._state.recording)
-      await this.stopChunk({ mode: "discard" });
+      await this.stopChunk(progress, { mode: "discard" });
     if (!this._state)
       throw new Error("Must start tracing before starting a new chunk");
     if (this._isStopping)
@@ -161,7 +165,7 @@ class Tracing extends import_instrumentation.SdkObject {
   _currentGroupId() {
     return this._state?.groupStack.length ? this._state.groupStack[this._state.groupStack.length - 1] : void 0;
   }
-  async group(name, location, metadata) {
+  group(name, location, metadata) {
     if (!this._state)
       return;
     const stackFrames = [];
@@ -177,7 +181,7 @@ class Tracing extends import_instrumentation.SdkObject {
       type: "before",
       callId: metadata.id,
       startTime: metadata.startTime,
-      apiName: name,
+      title: name,
       class: "Tracing",
       method: "tracingGroup",
       params: {},
@@ -232,7 +236,7 @@ class Tracing extends import_instrumentation.SdkObject {
       this._fs.copyFile(state.networkFile, newNetworkFile);
     state.networkFile = newNetworkFile;
   }
-  async stop() {
+  async stop(progress) {
     if (!this._state)
       return;
     if (this._isStopping)
@@ -242,8 +246,10 @@ class Tracing extends import_instrumentation.SdkObject {
     this._closeAllGroups();
     this._harTracer.stop();
     this.flushHarEntries();
-    await this._fs.syncAndGetError();
-    this._state = void 0;
+    const promise = progress ? progress.race(this._fs.syncAndGetError()) : this._fs.syncAndGetError();
+    await promise.finally(() => {
+      this._state = void 0;
+    });
   }
   async deleteTmpTracesDir() {
     if (this._tracesTmpDir)
@@ -267,7 +273,7 @@ class Tracing extends import_instrumentation.SdkObject {
     while (this._currentGroupId())
       this.groupEnd();
   }
-  async stopChunk(params) {
+  async stopChunk(progress, params) {
     if (this._isStopping)
       throw new Error(`Tracing is already stopping`);
     this._isStopping = true;
@@ -283,7 +289,7 @@ class Tracing extends import_instrumentation.SdkObject {
     if (this._state.options.screenshots)
       this._stopScreencast();
     if (this._state.options.snapshots)
-      await this._snapshotter?.stop();
+      this._snapshotter?.stop();
     this.flushHarEntries();
     const newNetworkFile = import_path.default.join(this._state.tracesDir, this._state.traceName + `-pwnetcopy-${this._state.chunkOrdinal}.network`);
     const entries = [];
@@ -301,12 +307,13 @@ class Tracing extends import_instrumentation.SdkObject {
     const zipFileName = this._state.traceFile + ".zip";
     if (params.mode === "archive")
       this._fs.zip(entries, zipFileName);
-    const error = await this._fs.syncAndGetError();
+    const promise = progress ? progress.race(this._fs.syncAndGetError()) : this._fs.syncAndGetError();
+    const error = await promise.catch((e) => e);
     this._isStopping = false;
     if (this._state)
       this._state.recording = false;
     if (error) {
-      if (this._context instanceof import_browserContext.BrowserContext && !this._context._browser.isConnected())
+      if (!(0, import_progress.isAbortError)(error) && this._context instanceof import_browserContext.BrowserContext && !this._context._browser.isConnected())
         return {};
       throw error;
     }
@@ -350,7 +357,9 @@ class Tracing extends import_instrumentation.SdkObject {
     return this._captureSnapshot(event.inputSnapshot, sdkObject, metadata);
   }
   onCallLog(sdkObject, metadata, logName, message) {
-    if (metadata.isServerSide || metadata.internal)
+    if (!this._state?.callIds.has(metadata.id))
+      return;
+    if (metadata.internal)
       return;
     if (logName !== "api")
       return;
@@ -535,7 +544,8 @@ function visitTraceEvent(object, sha1s) {
   return object;
 }
 function shouldCaptureSnapshot(metadata) {
-  return import_debug.commandsWithTracingSnapshots.has(metadata.type + "." + metadata.method);
+  const metainfo = import_protocolMetainfo.methodMetainfo.get(metadata.type + "." + metadata.method);
+  return !!metainfo?.snapshot;
 }
 function createBeforeActionTraceEvent(metadata, parentId) {
   if (metadata.internal || metadata.method.startsWith("tracing"))
@@ -544,7 +554,7 @@ function createBeforeActionTraceEvent(metadata, parentId) {
     type: "before",
     callId: metadata.id,
     startTime: metadata.startTime,
-    apiName: metadata.apiName || metadata.type + "." + metadata.method,
+    title: metadata.title,
     class: metadata.type,
     method: metadata.method,
     params: metadata.params,
@@ -588,6 +598,5 @@ function createAfterActionTraceEvent(metadata) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Tracing,
-  shouldCaptureSnapshot
+  Tracing
 });