browsertime 25.1.0 → 25.2.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Browsertime changelog (we do [semantic versioning](https://semver.org))
 
+## 25.1.0 - 2025-10-12
+### Added
+* Updated to Chrome/Chromedriver/Edge/Edgedriver 141, Firefox 143 [#2325](https://github.com/sitespeedio/browsertime/pull/2325) and [#2323](https://github.com/sitespeedio/browsertime/pull/2323).
+* Updated webdriver and bidi-har [#2322](https://github.com/sitespeedio/browsertime/pull/2322).
+
 ## 25.1.0 - 2025-09-05
 ### Added
 * Updated to Chrome/Chromedriver 140, Firefox 142 [#2318](https://github.com/sitespeedio/browsertime/pull/2318).

package/lib/android/index.js

@@ -1,5 +1,5 @@
 import { promisify } from 'node:util';
-import { mkdir as _mkdir, createWriteStream } from 'node:fs';
+import { mkdir as _mkdir, createWriteStream, createReadStream } from 'node:fs';
 import path from 'node:path';
 import { EOL as endOfLine } from 'node:os';
 import { execa } from 'execa';
@@ -100,6 +100,11 @@ export class Android {
     });
   }
 
+  async _uploadFile(sourcePath, destinationPath) {
+    log.debug(`Pushing to ${destinationPath} from ${sourcePath}`);
+    return this.device.push(createReadStream(sourcePath), destinationPath);
+  }
+
   async _downloadDir(sourcePath, destinationPath) {
     const files = await this.device.readdir(sourcePath);
 

package/lib/core/engine/command/perfetto.js

@@ -0,0 +1,215 @@
+import { getLogger } from '@sitespeed.io/log';
+const log = getLogger('browsertime.command.perfetto');
+import path from 'node:path';
+const { join } = path;
+import { writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { isAndroidConfigured, Android } from '../../../android/index.js';
+const delay = ms => new Promise(res => setTimeout(res, ms));
+/**
+ * Manages the collection of perfetto traces on Android.
+ *
+ * @class
+ * @hideconstructor
+ */
+
+// Default config that works for both chrome and firefox.  It contains
+// basic system information, but no track events.  Those must be specified
+// manually through perfetto.start(config).
+const defaultConfig = `write_into_file: true
+
+buffers: {
+    size_kb: 522240
+    fill_policy: DISCARD
+}
+buffers: {
+    size_kb: 2048
+    fill_policy: DISCARD
+}
+data_sources: {
+    config {
+        name: "android.packages_list"
+        target_buffer: 1
+    }
+}
+data_sources: {
+    config {
+        name: "linux.process_stats"
+        target_buffer: 1
+        process_stats_config {
+            scan_all_processes_on_start: true
+        }
+    }
+}
+data_sources: {
+    config {
+        name: "linux.ftrace"
+        ftrace_config {
+            ftrace_events: "power/suspend_resume"
+            ftrace_events: "power/cpu_frequency"
+            ftrace_events: "power/cpu_idle"
+            ftrace_events: "regulator/regulator_set_voltage"
+            ftrace_events: "regulator/regulator_set_voltage_complete"
+            ftrace_events: "power/clock_enable"
+            ftrace_events: "power/clock_disable"
+            ftrace_events: "power/clock_set_rate"
+        }
+    }
+}
+duration_ms: 60000`;
+export class PerfettoTrace {
+  constructor(browser, index, storageManager, options) {
+    /**
+     * @private
+     */
+    this.browser = browser;
+    /**
+     * @private
+     */
+    this.storageManager = storageManager;
+    /**
+     * @private
+     */
+    this.options = options;
+    /**
+     * @private
+     */
+    this.index = index;
+  }
+
+  async uploadConfigFile(android, config) {
+    let destinationFilename = join(this.dataDir, `perfetto-config.txt`);
+
+    try {
+      await writeFile(destinationFilename, config);
+    } catch (error) {
+      console.error(error);
+    }
+
+    return android._uploadFile(
+      destinationFilename,
+      '/sdcard/browsertime-perfetto-config.txt'
+    );
+  }
+
+  async downloadTrace() {
+    let destinationFilename = join(this.dataDir, `trace.perfetto`);
+    let deviceTraceFilename = '/data/misc/perfetto-traces/trace';
+    log.info(
+      `Downloading perfetto trace from ${deviceTraceFilename} to ${destinationFilename}`
+    );
+    return this.android._downloadFile(deviceTraceFilename, destinationFilename);
+  }
+
+  /**
+   * Begin Perfetto Trace Collection.
+   *
+   * @async
+   * @returns {Promise<void>} A promise that resolves when tracing is finished.
+   * @throws {Error} Throws an error if the configuration is not set for perfetto tracing.
+   */
+  async start(config = defaultConfig) {
+    if (!isAndroidConfigured(this.options)) {
+      throw new Error('Perfetto tracing is only available on Android.');
+    }
+
+    this.android = new Android(this.options);
+
+    // Create empty subdir for simpleperf data.
+    let dirname = `perfetto-${this.index}`;
+    let counter = 1;
+
+    while (true) {
+      log.info(`Checking if ${dirname} exists...`);
+      if (existsSync(join(this.storageManager.directory, dirname))) {
+        dirname = `perfetto-${this.index}.${counter}`;
+        counter++;
+        log.info(`Directory already exists.`);
+      } else {
+        this.dataDir = await this.storageManager.createSubDataDir(dirname);
+        log.info(`Creating subdir ${this.dataDir}.`);
+        break;
+      }
+    }
+    log.info('Finished creating directory.');
+
+    // Check if perfetto is enabled on this device.
+    const tracedEnabled = await this.android._runCommandAndGet(
+      `getprop persist.traced.enable`
+    );
+    if (tracedEnabled !== '1') {
+      log.info(`Disabling Perfetto: persist.traced.enable=${tracedEnabled}`);
+      return;
+    }
+
+    // Create the trace config on the device.
+    log.info('Creating perfetto config on device.');
+    await this.uploadConfigFile(this.android, config);
+    await delay(5000);
+
+    // Start perfetto trace and detach.
+    log.info('Starting perfetto tracing.');
+    const output = await this.android._runCommandAndGet(
+      'cat /sdcard/browsertime-perfetto-config.txt | perfetto -c - --txt --detach=browsertime -o /data/misc/perfetto-traces/trace'
+    );
+    log.info(`Perfetto starting output: ${output}`);
+
+    // Remove the config file.
+    await this.android.removeFileOnSdCard('browsertime-perfetto-config.txt');
+
+    return new Promise((resolve, reject) => {
+      if (output.includes('Connected to the Perfetto traced service')) {
+        this.running = true;
+        return resolve();
+      } else {
+        return reject();
+      }
+    });
+  }
+
+  /**
+   * Stop Perfetto Trace Collection.
+   *
+   * @async
+   * @returns {Promise<void>} A promise that resolves when tracing is finished and the perfetto
+   *                          trace has been collected.
+   * @throws {Error} Throws an error if the the perfetto session or trace was not found.
+   */
+  async stop() {
+    if (!isAndroidConfigured(this.options)) {
+      throw new Error('Perfetto tracing is only available on Android.');
+    }
+
+    if (!this.running) {
+      throw new Error('Perfetto tracing was not started.');
+    }
+
+    // Attach and stop perfetto trace.
+    log.info('Starting perfetto tracing.');
+    const output = await this.android._runCommandAndGet(
+      'perfetto --attach=browsertime --stop'
+    );
+    log.info(`Perfetto ending output: ${output}`);
+
+    let stopSuccessful = false;
+
+    if (output.includes('Trace written into the output file')) {
+      stopSuccessful = true;
+    } else {
+      const logcat = await this.android._runCommandAndGet(`logcat -d`);
+      if (/Tracing session \d+ ended, total sessions:0/.test(logcat)) {
+        log.info('Warning: Perfetto session ended prematurely.');
+        stopSuccessful = true;
+      }
+    }
+    this.running = false;
+
+    if (!stopSuccessful) {
+      throw new Error('Perfetto process failed or ended suddenly.');
+    }
+
+    log.info('Perfetto tracing finished.');
+    // Download perfetto trace.
+    return this.downloadTrace();
+  }
+}

package/lib/core/engine/command/simpleperf.js

@@ -0,0 +1,181 @@
+import { getLogger } from '@sitespeed.io/log';
+import path from 'node:path';
+const { join } = path;
+import { execa } from 'execa';
+import { existsSync, renameSync } from 'node:fs';
+import { isAndroidConfigured } from '../../../android/index.js';
+// const delay = ms => new Promise(res => setTimeout(res, ms));
+/**
+ * Manages the collection of perfetto traces on Android.
+ *
+ * @class
+ * @hideconstructor
+ */
+
+const log = getLogger('browsertime.command.simpleperf');
+
+const defaultOptions =
+  '--call-graph fp --duration 240 -f 1000 --trace-offcpu -e cpu-clock';
+
+/**
+ * Timeout a promise after ms. Use promise.race to compete
+ * about the timeout and the promise.
+ * @param {promise} promise - the promise to wait for
+ * @param {int} ms - how long in ms to wait for the promise to fininsh
+ * @param {string} errorMessage - the error message in the Error if we timeouts
+ */
+
+async function timeout(promise, ms, errorMessage) {
+  let timer;
+
+  return Promise.race([
+    new Promise((resolve, reject) => {
+      timer = setTimeout(reject, ms, new Error(errorMessage));
+      return timer;
+    }),
+    promise.then(value => {
+      clearTimeout(timer);
+      return value;
+    })
+  ]);
+}
+
+export class SimplePerfProfiler {
+  constructor(browser, index, storageManager, options) {
+    /**
+     * @private
+     */
+    this.browser = browser;
+    /**
+     * @private
+     */
+    this.storageManager = storageManager;
+    /**
+     * @private
+     */
+    this.options = options;
+    /**
+     * @private
+     */
+    this.index = index;
+    /**
+     * @private
+     */
+    this.running = false;
+  }
+
+  /**
+   * Start Simpleperf profiling.
+   *
+   * @async
+   * @returns {Promise<void>} A promise that resolves when simpleperf has started profiling.
+   * @throws {Error} Throws an error if app_profiler.py fails to execute.
+   */
+
+  async start(profilerOptions = defaultOptions, dirName = 'simpleperf') {
+    if (!isAndroidConfigured(this.options)) {
+      throw new Error('Simpleperf profiling is only available on Android.');
+    }
+
+    log.info('Starting simpleperf profiler.');
+
+    // Create empty subdirectory for simpleperf data.
+    let dirname = `${dirName}-${this.index}`;
+    let counter = 0;
+
+    while (true) {
+      log.info(`Checking if ${dirname} exists...`);
+
+      if (existsSync(join(this.storageManager.directory, dirname))) {
+        dirname = `${dirName}-${this.index}.${counter}`;
+        counter++;
+        log.info(`Directory already exists.`);
+      } else {
+        this.dataDir = await this.storageManager.createSubDataDir(dirname);
+        log.info(`Creating subdir ${this.dataDir}.`);
+        break;
+      }
+    }
+
+    // Execute simpleperf.
+    const packageName =
+      this.options.browser === 'firefox'
+        ? this.options.firefox?.android?.package
+        : this.options.chrome?.android?.package;
+    let ndkPath = this.options.androidNDK;
+    let cmd = `${ndkPath}/simpleperf/app_profiler.py`;
+    let args = [
+      '-p',
+      packageName,
+      '-r',
+      profilerOptions,
+      '--log',
+      'debug',
+      '-o',
+      join(this.dataDir, 'perf.data')
+    ];
+    this.simpleperfProcess = execa(cmd, args);
+
+    // Waiting for simpleperf to start.
+    let simpleperfPromise = new Promise((resolve, reject) => {
+      let stderrStream = this.simpleperfProcess.stderr;
+      stderrStream.on('data', data => {
+        let dataStr = data.toString();
+        log.info(dataStr);
+        if (/command 'record' starts running/.test(dataStr)) {
+          this.running = true;
+          stderrStream.removeAllListeners('data');
+          return resolve();
+        }
+        if (/Failed to record profiling data./.test(dataStr)) {
+          this.running = false;
+          log.info(`Error starting simpleperf: ${dataStr}`);
+          throw new Error('Simpleperf failed to start.');
+        }
+      });
+      stderrStream.once('error', reject);
+    });
+
+    // Set a 30s timeout for starting simpleperf.
+    return timeout(simpleperfPromise, 30_000, 'Simpleperf timed out.');
+  }
+
+  /**
+   * Stop Simpleperf profiling.
+   *
+   * @async
+   * @returns {Promise<void>} A promise that resolves when simpleperf has stopped profiling
+   *                          and collected profile data.
+   * @throws {Error} Throws an error if app_profiler.py fails to execute.
+   */
+  async stop() {
+    if (!isAndroidConfigured(this.options)) {
+      throw new Error('Simpleperf profiling is only available on Android.');
+    }
+
+    if (!this.running) {
+      throw new Error('Simpleperf profiling was not started.');
+    }
+
+    log.info('Stop simpleperf profiler.');
+    this.simpleperfProcess.kill('SIGINT');
+
+    // Return when "profiling is finished." is found, or an error.
+    return new Promise((resolve, reject) => {
+      let stderrStream = this.simpleperfProcess.stderr;
+      log.info('Reading stderr.');
+      stderrStream.on('data', data => {
+        const dataStr = data.toString();
+        log.info(dataStr);
+        if (/profiling is finished./.test(dataStr)) {
+          stderrStream.removeAllListeners('data');
+          // There is no way to specify the output of binary_cache, so manually move
+          // it into the data directory.
+          renameSync('binary_cache', join(this.dataDir, 'binary_cache'));
+          return resolve();
+        }
+      });
+      stderrStream.once('error', reject);
+    });
+  }
+}

package/lib/core/engine/commands.js

@@ -29,6 +29,8 @@ import { Navigation } from './command/navigation.js';
 import { GeckoProfiler } from '../../firefox/geckoProfiler.js';
 import { GeckoProfiler as GeckoProfilerCommand } from './command/geckoProfiler.js';
 import { PerfStatsInterface } from './command/perfStats.js';
+import { PerfettoTrace } from './command/perfetto.js';
+import { SimplePerfProfiler } from './command/simpleperf.js';
 /**
  * Represents the set of commands available in a Browsertime script.
  * @hideconstructor
@@ -65,6 +67,23 @@ export class Commands {
       options
     );
 
+    /**
+     * Provides functionality to collect perfetto traces.
+     * @type {PerfettoTrace}
+     */
+    this.perfetto = new PerfettoTrace(browser, index, storageManager, options);
+
+    /**
+     * Provides functionality to collect simpleperf profiles.
+     * @type {SimplePerfProfiler}
+     */
+    this.simpleperf = new SimplePerfProfiler(
+      browser,
+      index,
+      storageManager,
+      options
+    );
+
     /**
      * Manages GeckoProfiler functionality to collect performance profiles.
      * @type {GeckoProfiler}

package/lib/firefox/perfStats.js

@@ -6,15 +6,51 @@ export class PerfStats {
     this.runner = runner;
   }
 
-  async start(featureMask) {
+  async start(features) {
     const runner = this.runner;
-    const script = `ChromeUtils.setPerfStatsCollectionMask(${featureMask});`;
+
+    // Parse features if it's a string
+    let featuresArray = features;
+    if (typeof features === 'string') {
+      featuresArray = features
+        .split(',')
+        .map(f => f.trim())
+        .filter(f => f.length > 0);
+    }
+
+    // eslint-disable-next-line prettier/prettier
+    const allFeaturesMask = 0xFF_FF_FF_FF;
+
+    const script = `
+      if (typeof ChromeUtils.setPerfStatsFeatures === 'function') {
+        if (!${JSON.stringify(featuresArray)} || ${JSON.stringify(featuresArray)}.length === 0) {
+          ChromeUtils.enableAllPerfStatsFeatures();
+        } else {
+          ChromeUtils.setPerfStatsFeatures(${JSON.stringify(featuresArray)});
+        }
+      } else if (typeof ChromeUtils.setPerfStatsCollectionMask === 'function') {
+        ChromeUtils.setPerfStatsCollectionMask(${features || allFeaturesMask});
+      } else {
+        throw new Error('PerfStats API not available in this Firefox version');
+      }
+    `;
+
     return runner.runPrivilegedScript(script, 'Start PerfStats Measurement');
   }
 
   async stop() {
     const runner = this.runner;
-    const script = `ChromeUtils.setPerfStatsCollectionMask(0);`;
+
+    const script = `
+      if (typeof ChromeUtils.setPerfStatsFeatures === 'function') {
+        ChromeUtils.setPerfStatsFeatures([]);
+      } else if (typeof ChromeUtils.setPerfStatsCollectionMask === 'function') {
+        ChromeUtils.setPerfStatsCollectionMask(0);
+      } else {
+        throw new Error('PerfStats API not available in this Firefox version');
+      }
+    `;
+
     return runner.runPrivilegedScript(script, 'Stop PerfStats Measurement');
   }
 

package/lib/firefox/webdriver/firefox.js

@@ -177,7 +177,7 @@ export class Firefox {
 
     if (this.firefoxConfig.perfStats) {
       this.perfStats = new PerfStats(runner);
-      return this.perfStats.start(this.firefoxConfig.perfStatsParams.mask);
+      return this.perfStats.start(this.firefoxConfig.perfStatsParams?.features);
     }
 
     this.testStartTime = Date.now();

package/lib/support/cli.js

@@ -549,11 +549,10 @@ export function parseCommandLine() {
       type: 'boolean',
       group: 'firefox'
     })
-    .option('firefox.perfStatsParams.mask', {
-      describe: 'Mask to decide which features to enable',
-      // eslint-disable-next-line prettier/prettier
-      default: 0xFF_FF_FF_FF,
-      type: 'number',
+    .option('firefox.perfStatsParams.features', {
+      describe:
+        'Comma-separated list of PerfStats features to enable. If not provided, all features will be enabled.',
+      type: 'string',
       group: 'firefox'
     })
     .option('firefox.collectMozLog', {
@@ -838,6 +837,18 @@ export function parseCommandLine() {
         'Before a test start, verify that the device has a Internet connection by pinging 8.8.8.8 (or a configurable domain with --androidPingAddress)',
       group: 'android'
     })
+    .option('android.ndk', {
+      alias: 'androidNDK',
+      type: 'string',
+      describe: 'Path to the Android NDK (required for simpleperf profiling).',
+      group: 'android'
+    })
+    .option('android.perfettoTrace', {
+      alias: 'androidPerfettoTrace',
+      describe: 'Collect a perfetto trace with the given configuration.',
+      default: false,
+      group: 'android'
+    })
     /** Process start time.  Android-only for now. */
     .option('processStartTime', {
       type: 'boolean',

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "browsertime",
   "description": "Get performance metrics from your web page using Browsertime.",
-  "version": "25.1.0",
+  "version": "25.2.0",
   "bin": "./bin/browsertime.js",
   "type": "module",
   "types": "./types/scripting.d.ts",
   "dependencies": {
     "@devicefarmer/adbkit": "3.3.8",
-    "@sitespeed.io/chromedriver": "140.0.7339-80",
-    "@sitespeed.io/edgedriver": "138.0.3351-83",
+    "@sitespeed.io/chromedriver": "141.0.7390-76",
+    "@sitespeed.io/edgedriver": "141.0.3537-71",
     "@sitespeed.io/geckodriver": "0.36.0",
     "@sitespeed.io/log": "0.2.6",
     "@sitespeed.io/throttle": "5.0.1",
@@ -17,9 +17,9 @@
     "chrome-remote-interface": "0.33.3",
     "execa": "9.6.0",
     "fast-stats": "0.0.7",
-    "ff-test-bidi-har-export": "0.0.17",
+    "ff-test-bidi-har-export": "0.0.18",
     "lodash.merge": "4.6.2",
-    "selenium-webdriver": "4.35.0",
+    "selenium-webdriver": "4.36.0",
     "yargs": "18.0.0"
   },
   "optionalDependencies": {

package/types/android/index.d.ts

@@ -15,6 +15,7 @@ export class Android {
     _runAsRootAndGet(command: any): Promise<any>;
     _runAsRoot(command: any): Promise<boolean>;
     _downloadFile(sourcePath: any, destinationPath: any): Promise<any>;
+    _uploadFile(sourcePath: any, destinationPath: any): Promise<any>;
     _downloadDir(sourcePath: any, destinationPath: any): Promise<void>;
     getFullPathOnSdCard(path: any): string;
     mkDirOnSdCard(dirName: any): Promise<any>;

package/types/android/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/android/index.js"],"names":[],"mappings":"AAglBA,2DAWC;AA5kBD;IACE,0BAwBC;IAfC,YAAgC;IAEhC,QAIC;IACD,UAAgC;IAGhC,6BAA6B;IAC7B,yBAA2B;IAC3B,eAAgC;IAKlC,uBAgBC;IALC,YAA4C;IAG1C,YAAoE;IAIxE,wCAEC;IAED,8CAIC;IAED,6CAIC;IAED,2CAUC;IAED,mEAYC;IAED,mEAcC;IAED,uCAEC;IAED,0CAGC;IAED,4CAMC;IAED,4CAMC;IAED,uBAGC;IAED,kCAOC;IAED;;;;;;;OAuBC;IAED,2CAKC;IAED,8BAKC;IAED,oKAuBC;IAED,2BAIC;IAED,qCAGC;IAED,iCAGC;IAED,wBASC;IAED,2CAOC;IAED,gCAEC;IAED,0BAIC;IAED,iCAGC;IAED,8CAIC;IAED,4BAEC;IAED,sCAYC;IAED,mDAsBC;IAED,gDA+CC;IAED;;;;;;;OAqDC;IAED,4DAQC;IAED,mCAcC;IAED,kCAQC;IAED,iCAIC;IAED;;;;OAGC;IAED;;;OAEC;IAED,6GAaC;CACF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/android/index.js"],"names":[],"mappings":"AAqlBA,2DAWC;AAjlBD;IACE,0BAwBC;IAfC,YAAgC;IAEhC,QAIC;IACD,UAAgC;IAGhC,6BAA6B;IAC7B,yBAA2B;IAC3B,eAAgC;IAKlC,uBAgBC;IALC,YAA4C;IAG1C,YAAoE;IAIxE,wCAEC;IAED,8CAIC;IAED,6CAIC;IAED,2CAUC;IAED,mEAYC;IAED,iEAGC;IAED,mEAcC;IAED,uCAEC;IAED,0CAGC;IAED,4CAMC;IAED,4CAMC;IAED,uBAGC;IAED,kCAOC;IAED;;;;;;;OAuBC;IAED,2CAKC;IAED,8BAKC;IAED,oKAuBC;IAED,2BAIC;IAED,qCAGC;IAED,iCAGC;IAED,wBASC;IAED,2CAOC;IAED,gCAEC;IAED,0BAIC;IAED,iCAGC;IAED,8CAIC;IAED,4BAEC;IAED,sCAYC;IAED,mDAsBC;IAED,gDA+CC;IAED;;;;;;;OAqDC;IAED,4DAQC;IAED,mCAcC;IAED,kCAQC;IAED,iCAIC;IAED;;;;OAGC;IAED;;;OAEC;IAED,6GAaC;CACF"}

package/types/core/engine/command/perfetto.d.ts

@@ -0,0 +1,43 @@
+export class PerfettoTrace {
+    constructor(browser: any, index: any, storageManager: any, options: any);
+    /**
+     * @private
+     */
+    private browser;
+    /**
+     * @private
+     */
+    private storageManager;
+    /**
+     * @private
+     */
+    private options;
+    /**
+     * @private
+     */
+    private index;
+    uploadConfigFile(android: any, config: any): Promise<any>;
+    downloadTrace(): Promise<any>;
+    /**
+     * Begin Perfetto Trace Collection.
+     *
+     * @async
+     * @returns {Promise<void>} A promise that resolves when tracing is finished.
+     * @throws {Error} Throws an error if the configuration is not set for perfetto tracing.
+     */
+    start(config?: string): Promise<void>;
+    android: Android;
+    dataDir: any;
+    running: boolean;
+    /**
+     * Stop Perfetto Trace Collection.
+     *
+     * @async
+     * @returns {Promise<void>} A promise that resolves when tracing is finished and the perfetto
+     *                          trace has been collected.
+     * @throws {Error} Throws an error if the the perfetto session or trace was not found.
+     */
+    stop(): Promise<void>;
+}
+import { Android } from '../../../android/index.js';
+//# sourceMappingURL=perfetto.d.ts.map

package/types/core/engine/command/perfetto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perfetto.d.ts","sourceRoot":"","sources":["../../../../lib/core/engine/command/perfetto.js"],"names":[],"mappings":"AA2DA;IACE,yEAiBC;IAhBC;;OAEG;IACH,gBAAsB;IACtB;;OAEG;IACH,uBAAoC;IACpC;;OAEG;IACH,gBAAsB;IACtB;;OAEG;IACH,cAAkB;IAGpB,0DAaC;IAED,8BAOC;IAED;;;;;;OAMG;IACH,wBAHa,OAAO,CAAC,IAAI,CAAC,CA4DzB;IApDC,iBAAwC;IAapC,aAAkE;IAiClE,iBAAmB;IAQzB;;;;;;;OAOG;IACH,QAJa,OAAO,CAAC,IAAI,CAAC,CAwCzB;CACF;wBAhN4C,2BAA2B"}

package/types/core/engine/command/simpleperf.d.ts

@@ -0,0 +1,43 @@
+export class SimplePerfProfiler {
+    constructor(browser: any, index: any, storageManager: any, options: any);
+    /**
+     * @private
+     */
+    private browser;
+    /**
+     * @private
+     */
+    private storageManager;
+    /**
+     * @private
+     */
+    private options;
+    /**
+     * @private
+     */
+    private index;
+    /**
+     * @private
+     */
+    private running;
+    /**
+     * Start Simpleperf profiling.
+     *
+     * @async
+     * @returns {Promise<void>} A promise that resolves when simpleperf has started profiling.
+     * @throws {Error} Throws an error if app_profiler.py fails to execute.
+     */
+    start(profilerOptions?: string, dirName?: string): Promise<void>;
+    dataDir: any;
+    simpleperfProcess: import("execa").ResultPromise<{}>;
+    /**
+     * Stop Simpleperf profiling.
+     *
+     * @async
+     * @returns {Promise<void>} A promise that resolves when simpleperf has stopped profiling
+     *                          and collected profile data.
+     * @throws {Error} Throws an error if app_profiler.py fails to execute.
+     */
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=simpleperf.d.ts.map

package/types/core/engine/command/simpleperf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simpleperf.d.ts","sourceRoot":"","sources":["../../../../lib/core/engine/command/simpleperf.js"],"names":[],"mappings":"AA0CA;IACE,yEAqBC;IApBC;;OAEG;IACH,gBAAsB;IACtB;;OAEG;IACH,uBAAoC;IACpC;;OAEG;IACH,gBAAsB;IACtB;;OAEG;IACH,cAAkB;IAClB;;OAEG;IACH,gBAAoB;IAGtB;;;;;;OAMG;IAEH,mDAJa,OAAO,CAAC,IAAI,CAAC,CAsEzB;IA/CK,aAAkE;IAuBtE,qDAAyC;IA0B3C;;;;;;;OAOG;IACH,QAJa,OAAO,CAAC,IAAI,CAAC,CAiCzB;CACF"}

package/types/core/engine/commands.d.ts

@@ -4,6 +4,16 @@
  */
 export class Commands {
     constructor(browser: any, engineDelegate: any, index: any, result: any, storageManager: any, pageCompleteCheck: any, context: any, videos: any, screenshotManager: any, scriptsByCategory: any, asyncScriptsByCategory: any, postURLScripts: any, options: any);
+    /**
+     * Provides functionality to collect perfetto traces.
+     * @type {PerfettoTrace}
+     */
+    perfetto: PerfettoTrace;
+    /**
+     * Provides functionality to collect simpleperf profiles.
+     * @type {SimplePerfProfiler}
+     */
+    simpleperf: SimplePerfProfiler;
     profiler: GeckoProfilerCommand;
     perfStats: PerfStatsInterface;
     /**
@@ -144,6 +154,8 @@ export class Commands {
      */
     element: Element;
 }
+import { PerfettoTrace } from './command/perfetto.js';
+import { SimplePerfProfiler } from './command/simpleperf.js';
 import { GeckoProfiler as GeckoProfilerCommand } from './command/geckoProfiler.js';
 import { PerfStatsInterface } from './command/perfStats.js';
 import { ChromeTrace } from './command/chromeTrace.js';

package/types/core/engine/commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../lib/core/engine/commands.js"],"names":[],"mappings":"AA+BA;;;GAGG;AACH;IACE,gQAwPC;IAnNC,+BAMC;IAOD,8BAA0B;IAO1B;;;OAGG;IACH,OAFU,WAAW,CAE+C;IAEpE;;;OAGG;IACH,OAFU,KAAK,CAEmC;IAElD;;;OAGG;IACH,QAFU,MAAM,CAE0B;IAE1C;;;OAGG;IACH,SAFU,OAAO,CAEkB;IAEnC;;;OAGG;IACH,MAFU,IAAI,CAEkC;IAEhD;;;OAGG;IACH,SAFU,OAAO,CAEK;IAEtB;;;;;;;;OAQG;IACH,mBAA+C;IAE/C;;;OAGG;IACH,YAFU,UAAU,CAEwC;IAE5D;;;;;OAKG;IACH,gBAAyC;IAEzC;;;;;OAKG;IACH,wBAAmD;IAEnD;;;OAGG;IACH,IAFU,UAAU,CAEgC;IAEpD;;;OAGG;IACH,QAFU,MAAM,CAMf;IAED;;;OAGG;IACH,KAFU,GAAG,CAEc;IAE3B;;;OAGG;IACH,WAFU,SAAS,CAEoB;IAEvC;;;OAGG;IACH,OAFU,KAAK,CAEsC;IAErD;;;OAGG;IACH,MAFU,IAAI,CAEQ;IAEtB;;;OAGG;IACH,YAFU,UAAU,CAE+C;IAEnE;;;OAGG;IACH,KAFU,8BAA8B,CAE1B;IAEd;;;;OAIG;IACH,MAFU,IAAI,CAEuC;IAErD;;;OAGG;IACH,SAFU,cAAc,CAEkB;IAE1C;;;;OAIG;IACH,OAFW,KAAK,CAEwB;IAExC;;;OAGG;IACH,WA0BC;IAED;;;OAGG;IACH,QAFU,MAAM,CAEiB;IAEjC;;;;OAIG;IACH,QAHU,OAAO,CAGiB;IAElC;;;OAGG;IACH,SAFU,OAAO,CAEkB;CAEtC;sDAhQqD,4BAA4B;mCAC/C,wBAAwB;4BAZ/B,0BAA0B;sBAhBhC,oBAAoB;uBAwBnB,qBAAqB;wBAzBpB,sBAAsB;qBAGzB,mBAAmB;wBAChB,sBAAsB;2BAsBnB,yBAAyB;2BArBzB,yBAAyB;uBAC7B,qBAAqB;oBAExB,kBAAkB;mCAGH,wBAAwB;sBAFrC,oBAAoB;qBACrB,mBAAmB;2BAHb,yBAAyB;+CASL,qCAAqC;qBAF/D,mBAAmB;+BACT,sBAAsB;sBAF/B,oBAAoB;uBADnB,qBAAqB;wBAbpB,sBAAsB;wBAGtB,sBAAsB"}
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../lib/core/engine/commands.js"],"names":[],"mappings":"AAiCA;;;GAGG;AACH;IACE,gQAyQC;IA1OC;;;OAGG;IACH,UAFU,aAAa,CAEmD;IAE1E;;;OAGG;IACH,YAFU,kBAAkB,CAO3B;IAQD,+BAMC;IAOD,8BAA0B;IAO1B;;;OAGG;IACH,OAFU,WAAW,CAE+C;IAEpE;;;OAGG;IACH,OAFU,KAAK,CAEmC;IAElD;;;OAGG;IACH,QAFU,MAAM,CAE0B;IAE1C;;;OAGG;IACH,SAFU,OAAO,CAEkB;IAEnC;;;OAGG;IACH,MAFU,IAAI,CAEkC;IAEhD;;;OAGG;IACH,SAFU,OAAO,CAEK;IAEtB;;;;;;;;OAQG;IACH,mBAA+C;IAE/C;;;OAGG;IACH,YAFU,UAAU,CAEwC;IAE5D;;;;;OAKG;IACH,gBAAyC;IAEzC;;;;;OAKG;IACH,wBAAmD;IAEnD;;;OAGG;IACH,IAFU,UAAU,CAEgC;IAEpD;;;OAGG;IACH,QAFU,MAAM,CAMf;IAED;;;OAGG;IACH,KAFU,GAAG,CAEc;IAE3B;;;OAGG;IACH,WAFU,SAAS,CAEoB;IAEvC;;;OAGG;IACH,OAFU,KAAK,CAEsC;IAErD;;;OAGG;IACH,MAFU,IAAI,CAEQ;IAEtB;;;OAGG;IACH,YAFU,UAAU,CAE+C;IAEnE;;;OAGG;IACH,KAFU,8BAA8B,CAE1B;IAEd;;;;OAIG;IACH,MAFU,IAAI,CAEuC;IAErD;;;OAGG;IACH,SAFU,cAAc,CAEkB;IAE1C;;;;OAIG;IACH,OAFW,KAAK,CAEwB;IAExC;;;OAGG;IACH,WA0BC;IAED;;;OAGG;IACH,QAFU,MAAM,CAEiB;IAEjC;;;;OAIG;IACH,QAHU,OAAO,CAGiB;IAElC;;;OAGG;IACH,SAFU,OAAO,CAEkB;CAEtC;8BAjR6B,uBAAuB;mCAClB,yBAAyB;sDAHN,4BAA4B;mCAC/C,wBAAwB;4BAZ/B,0BAA0B;sBAhBhC,oBAAoB;uBAwBnB,qBAAqB;wBAzBpB,sBAAsB;qBAGzB,mBAAmB;wBAChB,sBAAsB;2BAsBnB,yBAAyB;2BArBzB,yBAAyB;uBAC7B,qBAAqB;oBAExB,kBAAkB;mCAGH,wBAAwB;sBAFrC,oBAAoB;qBACrB,mBAAmB;2BAHb,yBAAyB;+CASL,qCAAqC;qBAF/D,mBAAmB;+BACT,sBAAsB;sBAF/B,oBAAoB;uBADnB,qBAAqB;wBAbpB,sBAAsB;wBAGtB,sBAAsB"}

package/types/firefox/perfStats.d.ts

@@ -1,7 +1,7 @@
 export class PerfStats {
     constructor(runner: any);
     runner: any;
-    start(featureMask: any): Promise<any>;
+    start(features: any): Promise<any>;
     stop(): Promise<any>;
     collect(): Promise<{}>;
 }

package/types/firefox/perfStats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"perfStats.d.ts","sourceRoot":"","sources":["../../lib/firefox/perfStats.js"],"names":[],"mappings":"AAGA;IACE,yBAEC;IADC,YAAoB;IAGtB,sCAIC;IAED,qBAIC;IAED,uBAuCC;CACF"}
+{"version":3,"file":"perfStats.d.ts","sourceRoot":"","sources":["../../lib/firefox/perfStats.js"],"names":[],"mappings":"AAGA;IACE,yBAEC;IADC,YAAoB;IAGtB,mCA8BC;IAED,qBAcC;IAED,uBAuCC;CACF"}