patchright-core 1.56.1 → 1.58.2

package/lib/server/registry/oopDownloadBrowserMain.js

@@ -29,6 +29,7 @@ var import_path = __toESM(require("path"));
 var import_manualPromise = require("../../utils/isomorphic/manualPromise");
 var import_network = require("../utils/network");
 var import_zipBundle = require("../../zipBundle");
+var import_fileUtils = require("../utils/fileUtils");
 function log(message) {
   process.send?.({ method: "log", params: { message } });
 }
@@ -41,6 +42,7 @@ function browserDirectoryToMarkerFilePath(browserDirectory) {
 function downloadFile(options) {
   let downloadedBytes = 0;
   let totalBytes = 0;
+  let chunked = false;
   const promise = new import_manualPromise.ManualPromise();
   (0, import_network.httpRequest)({
     url: options.url,
@@ -60,11 +62,13 @@ function downloadFile(options) {
       response.on("data", (chunk) => content += chunk).on("end", handleError).on("error", handleError);
       return;
     }
+    chunked = response.headers["transfer-encoding"] === "chunked";
+    log(`-- is chunked: ${chunked}`);
     totalBytes = parseInt(response.headers["content-length"] || "0", 10);
     log(`-- total bytes: ${totalBytes}`);
     const file = import_fs.default.createWriteStream(options.zipPath);
     file.on("finish", () => {
-      if (downloadedBytes !== totalBytes) {
+      if (!chunked && downloadedBytes !== totalBytes) {
         log(`-- download failed, size mismatch: ${downloadedBytes} != ${totalBytes}`);
         promise.reject(new Error(`Download failed: size mismatch, file size: ${downloadedBytes}, expected size: ${totalBytes} URL: ${options.url}`));
       } else {
@@ -89,12 +93,15 @@ function downloadFile(options) {
   return promise;
   function onData(chunk) {
     downloadedBytes += chunk.length;
-    progress(downloadedBytes, totalBytes);
+    if (!chunked)
+      progress(downloadedBytes, totalBytes);
   }
 }
 async function main(options) {
   await downloadFile(options);
   log(`SUCCESS downloading ${options.title}`);
+  log(`removing existing browser directory if any`);
+  await (0, import_fileUtils.removeFolders)([options.browserDirectory]);
   log(`extracting archive`);
   await (0, import_zipBundle.extract)(options.zipPath, { dir: options.browserDirectory });
   if (options.executablePath) {

package/lib/server/screencast.js

@@ -0,0 +1,190 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var screencast_exports = {};
+__export(screencast_exports, {
+  Screencast: () => Screencast
+});
+module.exports = __toCommonJS(screencast_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("../utils");
+var import_utils2 = require("../utils");
+var import_videoRecorder = require("./videoRecorder");
+var import_page = require("./page");
+var import_registry = require("./registry");
+class Screencast {
+  constructor(page) {
+    this._videoRecorder = null;
+    this._videoId = null;
+    this._screencastClients = /* @__PURE__ */ new Set();
+    // Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
+    // When throttling for tracing, 200ms between frames, except for 10 frames around the action.
+    this._frameThrottler = new FrameThrottler(10, 35, 200);
+    this._frameListener = null;
+    this._page = page;
+  }
+  stopFrameThrottler() {
+    this._frameThrottler.dispose();
+  }
+  setOptions(options) {
+    this._setOptions(options).catch((e) => import_utils2.debugLogger.log("error", e));
+    this._frameThrottler.setThrottlingEnabled(!!options);
+  }
+  throttleFrameAck(ack) {
+    this._frameThrottler.ack(ack);
+  }
+  temporarilyDisableThrottling() {
+    this._frameThrottler.recharge();
+  }
+  launchVideoRecorder() {
+    const recordVideo = this._page.browserContext._options.recordVideo;
+    if (!recordVideo)
+      return void 0;
+    (0, import_utils.assert)(!this._videoId);
+    this._videoId = (0, import_utils.createGuid)();
+    const outputFile = import_path.default.join(recordVideo.dir, this._videoId + ".webm");
+    const videoOptions = {
+      // validateBrowserContextOptions ensures correct video size.
+      ...recordVideo.size,
+      outputFile
+    };
+    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.browserContext._browser.sdkLanguage());
+    this._videoRecorder = new import_videoRecorder.VideoRecorder(ffmpegPath, videoOptions);
+    this._frameListener = import_utils.eventsHelper.addEventListener(this._page, import_page.Page.Events.ScreencastFrame, (frame) => this._videoRecorder.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3));
+    this._page.waitForInitializedOrError().then((p) => {
+      if (p instanceof Error)
+        this.stopVideoRecording().catch(() => {
+        });
+    });
+    return videoOptions;
+  }
+  async startVideoRecording(options) {
+    const videoId = this._videoId;
+    (0, import_utils.assert)(videoId);
+    this._page.once(import_page.Page.Events.Close, () => this.stopVideoRecording().catch(() => {
+    }));
+    const gotFirstFrame = new Promise((f) => this._page.once(import_page.Page.Events.ScreencastFrame, f));
+    await this._startScreencast(this._videoRecorder, {
+      quality: 90,
+      width: options.width,
+      height: options.height
+    });
+    gotFirstFrame.then(() => {
+      this._page.browserContext._browser._videoStarted(this._page.browserContext, videoId, options.outputFile, this._page.waitForInitializedOrError());
+    });
+  }
+  async stopVideoRecording() {
+    if (!this._videoId)
+      return;
+    if (this._frameListener)
+      import_utils.eventsHelper.removeEventListeners([this._frameListener]);
+    this._frameListener = null;
+    const videoId = this._videoId;
+    this._videoId = null;
+    const videoRecorder = this._videoRecorder;
+    this._videoRecorder = null;
+    await this._stopScreencast(videoRecorder);
+    await videoRecorder.stop();
+    const video = this._page.browserContext._browser._takeVideo(videoId);
+    video?.reportFinished();
+  }
+  async _setOptions(options) {
+    if (options)
+      await this._startScreencast(this, options);
+    else
+      await this._stopScreencast(this);
+  }
+  async _startScreencast(client, options) {
+    this._screencastClients.add(client);
+    if (this._screencastClients.size === 1) {
+      await this._page.delegate.startScreencast({
+        width: options.width,
+        height: options.height,
+        quality: options.quality
+      });
+    }
+  }
+  async _stopScreencast(client) {
+    this._screencastClients.delete(client);
+    if (!this._screencastClients.size)
+      await this._page.delegate.stopScreencast();
+  }
+}
+class FrameThrottler {
+  constructor(nonThrottledFrames, defaultInterval, throttlingInterval) {
+    this._acks = [];
+    this._throttlingEnabled = false;
+    this._nonThrottledFrames = nonThrottledFrames;
+    this._budget = nonThrottledFrames;
+    this._defaultInterval = defaultInterval;
+    this._throttlingInterval = throttlingInterval;
+    this._tick();
+  }
+  dispose() {
+    if (this._timeoutId) {
+      clearTimeout(this._timeoutId);
+      this._timeoutId = void 0;
+    }
+  }
+  setThrottlingEnabled(enabled) {
+    this._throttlingEnabled = enabled;
+  }
+  recharge() {
+    for (const ack of this._acks)
+      ack();
+    this._acks = [];
+    this._budget = this._nonThrottledFrames;
+    if (this._timeoutId) {
+      clearTimeout(this._timeoutId);
+      this._tick();
+    }
+  }
+  ack(ack) {
+    if (!this._timeoutId) {
+      ack();
+      return;
+    }
+    this._acks.push(ack);
+  }
+  _tick() {
+    const ack = this._acks.shift();
+    if (ack) {
+      --this._budget;
+      ack();
+    }
+    if (this._throttlingEnabled && this._budget <= 0) {
+      this._timeoutId = setTimeout(() => this._tick(), this._throttlingInterval);
+    } else {
+      this._timeoutId = setTimeout(() => this._tick(), this._defaultInterval);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Screencast
+});

package/lib/server/screenshotter.js

@@ -213,6 +213,12 @@ class Screenshotter {
     if (disableAnimations)
       progress.log("  disabled all CSS animations");
     const syncAnimations = this._page.delegate.shouldToggleStyleSheetToSyncAnimations();
+    await Promise.all(this._page.frames().map(async (f) => {
+      try {
+        await f._utilityContext();
+      } catch {
+      }
+    }));
     await progress.race(this._page.safeNonStallingEvaluateInAllFrames("(" + inPagePrepareForScreenshots.toString() + `)(${JSON.stringify(screenshotStyle)}, ${hideCaret}, ${disableAnimations}, ${syncAnimations})`, "utility"));
     try {
       if (!process.env.PW_TEST_SCREENSHOT_NO_FONTS_READY) {

package/lib/server/socksClientCertificatesInterceptor.js

@@ -82,7 +82,7 @@ class SocksProxyConnection {
   async connect() {
     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 });
+      this._serverEncrypted = await proxyAgent.connect(new import_events.EventEmitter(), { host: rewriteToLocalhostIfNeeded(this.host), port: this.port, secureEndpoint: false });
     else
       this._serverEncrypted = await (0, import_happyEyeballs.createSocket)(rewriteToLocalhostIfNeeded(this.host), this.port);
     this._serverEncrypted.once("close", this._serverCloseEventListener);

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

@@ -49,7 +49,7 @@ class Snapshotter {
   }
   async reset() {
     if (this._started)
-      await this._context.safeNonStallingEvaluateInAllFrames(`window["${this._snapshotStreamer}"].reset()`, "main");
+      await this._context.safeNonStallingEvaluateInAllFrames(`window["${this._snapshotStreamer}"].reset()`, "utility");
   }
   stop() {
     this._started = false;
@@ -57,20 +57,20 @@ class Snapshotter {
   async resetForReuse() {
     if (this._initScript) {
       import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
-      await this._context.removeInitScripts([this._initScript]);
       this._initScript = void 0;
+      this._initScriptSource = void 0;
     }
   }
   async _initialize() {
+    const { javaScriptEnabled } = this._context._options;
+    this._initScriptSource = `(${import_snapshotterInjected.frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === void 0})`;
+    this._initScript = true;
     for (const page of this._context.pages())
       this._onPage(page);
     this._eventListeners = [
       import_eventsHelper.eventsHelper.addEventListener(this._context, import_browserContext.BrowserContext.Events.Page, this._onPage.bind(this))
     ];
-    const { javaScriptEnabled } = this._context._options;
-    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");
+    await this._context.safeNonStallingEvaluateInAllFrames(this._initScriptSource, "utility");
   }
   dispose() {
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
@@ -80,7 +80,7 @@ class Snapshotter {
     frame[kNeedsResetSymbol] = false;
     const expression = `window["${this._snapshotStreamer}"].captureSnapshot(${needsReset ? "true" : "false"})`;
     try {
-      return await frame.nonStallingRawEvaluateInExistingMainContext(expression);
+      return await frame.nonStallingEvaluateInExistingContext(expression, "utility");
     } catch (e) {
       frame[kNeedsResetSymbol] = true;
       import_debugLogger.debugLogger.log("error", e);
@@ -124,6 +124,7 @@ class Snapshotter {
     for (const frame of page.frames())
       this._annotateFrameHierarchy(frame);
     this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(page, import_page.Page.Events.FrameAttached, (frame) => this._annotateFrameHierarchy(frame)));
+    this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(page, import_page.Page.Events.InternalFrameNavigatedToNewDocument, (frame) => this._onFrameNavigated(frame)));
   }
   async _annotateFrameHierarchy(frame) {
     try {
@@ -131,7 +132,7 @@ class Snapshotter {
       const parent = frame.parentFrame();
       if (!parent)
         return;
-      const context = await parent._mainContext();
+      const context = await parent._utilityContext();
       await context?.evaluate(({ snapshotStreamer, frameElement: frameElement2, frameId }) => {
         window[snapshotStreamer].markIframe(frameElement2, frameId);
       }, { snapshotStreamer: this._snapshotStreamer, frameElement, frameId: frame.guid });
@@ -139,6 +140,14 @@ class Snapshotter {
     } catch (e) {
     }
   }
+  async _onFrameNavigated(frame) {
+    if (!this._initScriptSource)
+      return;
+    try {
+      await frame.nonStallingEvaluateInExistingContext(this._initScriptSource, "utility");
+    } catch (e) {
+    }
+  }
 }
 const kNeedsResetSymbol = Symbol("kNeedsReset");
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -60,23 +60,11 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
   class Streamer {
     constructor() {
       this._lastSnapshotNumber = 0;
-      this._staleStyleSheets = /* @__PURE__ */ new Set();
-      this._readingStyleSheet = false;
-      const invalidateCSSGroupingRule = (rule) => {
-        if (rule.parentStyleSheet)
-          this._invalidateStyleSheet(rule.parentStyleSheet);
-      };
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "insertRule", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "deleteRule", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "addRule", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "removeRule", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeGetter(window.CSSStyleSheet.prototype, "rules", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeGetter(window.CSSStyleSheet.prototype, "cssRules", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "replaceSync", (sheet) => this._invalidateStyleSheet(sheet));
-      this._interceptNativeMethod(window.CSSGroupingRule.prototype, "insertRule", invalidateCSSGroupingRule);
-      this._interceptNativeMethod(window.CSSGroupingRule.prototype, "deleteRule", invalidateCSSGroupingRule);
-      this._interceptNativeGetter(window.CSSGroupingRule.prototype, "cssRules", invalidateCSSGroupingRule);
-      this._interceptNativeAsyncMethod(window.CSSStyleSheet.prototype, "replace", (sheet) => this._invalidateStyleSheet(sheet));
+      this._modifiedStyleSheets = /* @__PURE__ */ new Set();
+      this._interceptNativeSetter(window.StyleSheet.prototype, "disabled", (sheet) => {
+        if (sheet instanceof CSSStyleSheet)
+          this._invalidateStyleSheet(sheet);
+      });
       this._fakeBase = document.createElement("base");
       this._observer = new MutationObserver((list) => this._handleMutations(list));
       const observerConfig = { attributes: true, subtree: true };
@@ -117,33 +105,13 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
           delete event.composedPath()[0].__playwright_target__;
       });
     }
-    _interceptNativeMethod(obj, method, cb) {
-      const native = obj[method];
-      if (!native)
-        return;
-      obj[method] = function(...args) {
-        const result = native.call(this, ...args);
-        cb(this, result);
-        return result;
-      };
-    }
-    _interceptNativeAsyncMethod(obj, method, cb) {
-      const native = obj[method];
-      if (!native)
-        return;
-      obj[method] = async function(...args) {
-        const result = await native.call(this, ...args);
-        cb(this, result);
-        return result;
-      };
-    }
-    _interceptNativeGetter(obj, prop, cb) {
+    _interceptNativeSetter(obj, prop, cb) {
       const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
       Object.defineProperty(obj, prop, {
         ...descriptor,
-        get: function() {
-          const result = descriptor.get.call(this);
-          cb(this, result);
+        set: function(value) {
+          const result = descriptor.set.call(this, value);
+          cb(this, value);
           return result;
         }
       });
@@ -152,42 +120,37 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
       for (const mutation of list)
         ensureCachedData(mutation.target).attributesCached = void 0;
     }
-    _invalidateStyleSheet(sheet) {
-      if (this._readingStyleSheet)
-        return;
-      this._staleStyleSheets.add(sheet);
-    }
     _updateStyleElementStyleSheetTextIfNeeded(sheet, forceText) {
       const data = ensureCachedData(sheet);
-      if (this._staleStyleSheets.has(sheet) || forceText && data.cssText === void 0) {
-        this._staleStyleSheets.delete(sheet);
-        try {
-          data.cssText = this._getSheetText(sheet);
-        } catch (e) {
-          data.cssText = "";
-        }
+      try {
+        data.cssText = this._getSheetText(sheet);
+      } catch (e) {
+        data.cssText = "";
       }
       return data.cssText;
     }
     // Returns either content, ref, or no override.
     _updateLinkStyleSheetTextIfNeeded(sheet, snapshotNumber) {
       const data = ensureCachedData(sheet);
-      if (this._staleStyleSheets.has(sheet)) {
-        this._staleStyleSheets.delete(sheet);
-        try {
-          data.cssText = this._getSheetText(sheet);
-          data.cssRef = snapshotNumber;
-          return data.cssText;
-        } catch (e) {
+      try {
+        const currentText = this._getSheetText(sheet);
+        if (data.cssText === void 0) {
+          data.cssText = currentText;
+          return void 0;
         }
+        if (currentText === data.cssText)
+          return data.cssRef === void 0 ? void 0 : snapshotNumber - data.cssRef;
+        data.cssText = currentText;
+        data.cssRef = snapshotNumber;
+        return data.cssText;
+      } catch (e) {
+        return void 0;
       }
-      return data.cssRef === void 0 ? void 0 : snapshotNumber - data.cssRef;
     }
     markIframe(iframeElement, frameId) {
       iframeElement[kSnapshotFrameId] = frameId;
     }
     reset() {
-      this._staleStyleSheets.clear();
       const visitNode = (node) => {
         resetCachedData(node);
         if (node.nodeType === Node.ELEMENT_NODE) {
@@ -246,15 +209,10 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
       return document.baseURI;
     }
     _getSheetText(sheet) {
-      this._readingStyleSheet = true;
-      try {
-        const rules = [];
-        for (const rule of sheet.cssRules)
-          rules.push(rule.cssText);
-        return rules.join("\n");
-      } finally {
-        this._readingStyleSheet = false;
-      }
+      const rules = [];
+      for (const rule of sheet.cssRules)
+        rules.push(rule.cssText);
+      return rules.join("\n");
     }
     captureSnapshot(needsReset) {
       const timestamp = performance.now();
@@ -518,7 +476,7 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
         wallTime: Date.now(),
         collectionTime: 0
       };
-      for (const sheet of this._staleStyleSheets) {
+      for (const sheet of this._modifiedStyleSheets) {
         if (sheet.href === null)
           continue;
         const content = this._updateLinkStyleSheetTextIfNeeded(sheet, snapshotNumber);

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

@@ -40,6 +40,7 @@ var import_assert = require("../../../utils/isomorphic/assert");
 var import_time = require("../../../utils/isomorphic/time");
 var import_eventsHelper = require("../../utils/eventsHelper");
 var import_crypto = require("../../utils/crypto");
+var import_userAgent = require("../../utils/userAgent");
 var import_artifact = require("../../artifact");
 var import_browserContext = require("../../browserContext");
 var import_dispatcher = require("../../dispatchers/dispatcher");
@@ -74,6 +75,7 @@ class Tracing extends import_instrumentation.SdkObject {
       type: "context-options",
       origin: "library",
       browserName: "",
+      playwrightVersion: (0, import_userAgent.getPlaywrightVersion)(),
       options: {},
       platform: process.platform,
       wallTime: 0,
@@ -220,7 +222,7 @@ class Tracing extends import_instrumentation.SdkObject {
     if (!(this._context instanceof import_browserContext.BrowserContext))
       return;
     for (const page of this._context.pages())
-      page.setScreencastOptions(null);
+      page.screencast.setOptions(null);
   }
   _allocateNewTraceFile(state) {
     const suffix = state.chunkOrdinal ? `-chunk${state.chunkOrdinal}` : ``;
@@ -324,23 +326,21 @@ class Tracing extends import_instrumentation.SdkObject {
     return { artifact };
   }
   async _captureSnapshot(snapshotName, sdkObject, metadata) {
-    if (!this._snapshotter)
+    if (!snapshotName || !sdkObject.attribution.page)
       return;
-    if (!sdkObject.attribution.page)
-      return;
-    if (!this._snapshotter.started())
-      return;
-    if (!shouldCaptureSnapshot(metadata))
-      return;
-    await this._snapshotter.captureSnapshot(sdkObject.attribution.page, metadata.id, snapshotName).catch(() => {
+    await this._snapshotter?.captureSnapshot(sdkObject.attribution.page, metadata.id, snapshotName).catch(() => {
     });
   }
-  onBeforeCall(sdkObject, metadata) {
-    const event = createBeforeActionTraceEvent(metadata, this._currentGroupId());
+  _shouldCaptureSnapshot(sdkObject, metadata) {
+    return !!this._snapshotter?.started() && shouldCaptureSnapshot(metadata) && !!sdkObject.attribution.page;
+  }
+  onBeforeCall(sdkObject, metadata, parentId) {
+    const event = createBeforeActionTraceEvent(metadata, parentId ?? this._currentGroupId());
     if (!event)
       return Promise.resolve();
-    sdkObject.attribution.page?.temporarilyDisableTracingScreencastThrottling();
-    event.beforeSnapshot = `before@${metadata.id}`;
+    sdkObject.attribution.page?.screencast.temporarilyDisableThrottling();
+    if (this._shouldCaptureSnapshot(sdkObject, metadata))
+      event.beforeSnapshot = `before@${metadata.id}`;
     this._state?.callIds.add(metadata.id);
     this._appendTraceEvent(event);
     return this._captureSnapshot(event.beforeSnapshot, sdkObject, metadata);
@@ -351,8 +351,9 @@ class Tracing extends import_instrumentation.SdkObject {
     const event = createInputActionTraceEvent(metadata);
     if (!event)
       return Promise.resolve();
-    sdkObject.attribution.page?.temporarilyDisableTracingScreencastThrottling();
-    event.inputSnapshot = `input@${metadata.id}`;
+    sdkObject.attribution.page?.screencast.temporarilyDisableThrottling();
+    if (this._shouldCaptureSnapshot(sdkObject, metadata))
+      event.inputSnapshot = `input@${metadata.id}`;
     this._appendTraceEvent(event);
     return this._captureSnapshot(event.inputSnapshot, sdkObject, metadata);
   }
@@ -367,15 +368,16 @@ class Tracing extends import_instrumentation.SdkObject {
     if (event)
       this._appendTraceEvent(event);
   }
-  async onAfterCall(sdkObject, metadata) {
+  onAfterCall(sdkObject, metadata) {
     if (!this._state?.callIds.has(metadata.id))
-      return;
+      return Promise.resolve();
     this._state?.callIds.delete(metadata.id);
     const event = createAfterActionTraceEvent(metadata);
     if (!event)
-      return;
-    sdkObject.attribution.page?.temporarilyDisableTracingScreencastThrottling();
-    event.afterSnapshot = `after@${metadata.id}`;
+      return Promise.resolve();
+    sdkObject.attribution.page?.screencast.temporarilyDisableThrottling();
+    if (this._shouldCaptureSnapshot(sdkObject, metadata))
+      event.afterSnapshot = `after@${metadata.id}`;
     this._appendTraceEvent(event);
     return this._captureSnapshot(event.afterSnapshot, sdkObject, metadata);
   }
@@ -482,7 +484,7 @@ class Tracing extends import_instrumentation.SdkObject {
     this._appendTraceEvent(event);
   }
   _startScreencastInPage(page) {
-    page.setScreencastOptions(kScreencastOptions);
+    page.screencast.setOptions(kScreencastOptions);
     const prefix = page.guid;
     this._screencastListeners.push(
       import_eventsHelper.eventsHelper.addEventListener(page, import_page.Page.Events.ScreencastFrame, (params) => {
@@ -548,6 +550,8 @@ function shouldCaptureSnapshot(metadata) {
   return !!metainfo?.snapshot;
 }
 function createBeforeActionTraceEvent(metadata, parentId) {
+  if (metadata.type === "Route" && metadata.method === "continue" && metadata.params?.isFallback)
+    return null;
   if (metadata.internal || metadata.method.startsWith("tracing"))
     return null;
   const event = {
@@ -566,6 +570,8 @@ function createBeforeActionTraceEvent(metadata, parentId) {
   return event;
 }
 function createInputActionTraceEvent(metadata) {
+  if (metadata.type === "Route" && metadata.method === "continue" && metadata.params?.isFallback)
+    return null;
   if (metadata.internal || metadata.method.startsWith("tracing"))
     return null;
   return {
@@ -575,6 +581,8 @@ function createInputActionTraceEvent(metadata) {
   };
 }
 function createActionLogTraceEvent(metadata, message) {
+  if (metadata.type === "Route" && metadata.method === "continue" && metadata.params?.isFallback)
+    return null;
   if (metadata.internal || metadata.method.startsWith("tracing"))
     return null;
   return {
@@ -585,6 +593,8 @@ function createActionLogTraceEvent(metadata, message) {
   };
 }
 function createAfterActionTraceEvent(metadata) {
+  if (metadata.type === "Route" && metadata.method === "continue" && metadata.params?.isFallback)
+    return null;
   if (metadata.internal || metadata.method.startsWith("tracing"))
     return null;
   return {