lighthouse 13.5.0-dev.20261021 → 13.5.0-dev.20261022

package/cli/cli-flags.js

@@ -232,7 +232,8 @@ function getYargsParser(manualArgv) {
       'output-path': {
         type: 'string',
         coerce: coerceOutputPath,
-        describe: `The file path to output the results. Use 'stdout' to write to stdout.
+        describe: `The file or directory path to output the results. Use 'stdout' to write to stdout.
+Directories in the path must already exist. If a directory is specified, the file name will be based on the test URL and date.
 If using JSON output, default is stdout.
 If using HTML or CSV output, default is a file in the working directory with a name based on the test URL and date.
 If using multiple outputs, --output-path is appended with the standard extension for each output type. "reports/my-run" -> "reports/my-run.report.html", "reports/my-run.report.json", etc.

package/core/computed/unused-css.js

@@ -66,8 +66,21 @@ class UnusedCSS {
     let usedUncompressedBytes = 0;
     const totalUncompressedBytes = stylesheetInfo.content.length;
 
-    for (const usedRule of stylesheetInfo.usedRules) {
-      usedUncompressedBytes += usedRule.endOffset - usedRule.startOffset;
+    // CSS rule usage tracking can return overlapping ranges (e.g. a nested rule inside its
+    // parent rule's range) or duplicate ranges (parent rules are emitted once per used child rule).
+    // Sort and merge overlapping ranges so used bytes are only counted once.
+    const usedRules = stylesheetInfo.usedRules
+      .slice()
+      .sort((a, b) => a.startOffset - b.startOffset);
+
+    let lastEndOffset = -1;
+    for (const usedRule of usedRules) {
+      if (usedRule.endOffset <= lastEndOffset) {
+        continue;
+      }
+      const startOffset = Math.max(usedRule.startOffset, lastEndOffset);
+      usedUncompressedBytes += usedRule.endOffset - startOffset;
+      lastEndOffset = usedRule.endOffset;
     }
 
     const compressedSize = estimateCompressedContentSize(

package/core/config/lr-desktop-config.js

@@ -24,6 +24,19 @@ const config = {
       'bf-cache',
     ],
   },
+  audits: [
+    // Lightrider does not support WebSocket connections.
+    // See https://github.com/GoogleChrome/lighthouse/issues/12459
+    {
+      path: 'errors-in-console',
+      options: {
+        ignoredPatterns: [
+          'ERR_BLOCKED_BY_CLIENT.Inspector',
+          /^WebSocket connection to 'wss?:\/\/.*' failed:/,
+        ],
+      },
+    },
+  ],
 };
 
 export default config;

package/core/config/lr-mobile-config.js

@@ -24,6 +24,19 @@ const config = {
       'bf-cache',
     ],
   },
+  audits: [
+    // Lightrider does not support WebSocket connections.
+    // See https://github.com/GoogleChrome/lighthouse/issues/12459
+    {
+      path: 'errors-in-console',
+      options: {
+        ignoredPatterns: [
+          'ERR_BLOCKED_BY_CLIENT.Inspector',
+          /^WebSocket connection to 'wss?:\/\/.*' failed:/,
+        ],
+      },
+    },
+  ],
 };
 
 export default config;

package/core/gather/gatherers/trace.d.ts

@@ -1,6 +1,12 @@
 export default Trace;
 declare class Trace extends BaseGatherer {
     static getDefaultTraceCategories(): string[];
+    /**
+     * @param {LH.Gatherer.ProtocolSession} session
+     * @param {string} handle
+     * @return {Promise<LH.Trace>}
+     */
+    static _readTraceFromStream(session: LH.Gatherer.ProtocolSession, handle: string): Promise<LH.Trace>;
     /**
      * @param {LH.Gatherer.ProtocolSession} session
      * @return {Promise<LH.Trace>}

package/core/gather/gatherers/trace.js

@@ -73,29 +73,68 @@ class Trace extends BaseGatherer {
 
   /**
    * @param {LH.Gatherer.ProtocolSession} session
+   * @param {string} handle
    * @return {Promise<LH.Trace>}
    */
-  static async endTraceAndCollectEvents(session) {
+  static async _readTraceFromStream(session, handle) {
     /** @type {Array<LH.TraceEvent>} */
     const traceEvents = [];
+    const decoder = new TextDecoder();
+    let isEof = false;
+    let remainder = '';
+
+    try {
+      while (!isEof) {
+        const response = await session.sendCommand('IO.read', {handle});
+        isEof = Boolean(response.eof);
+        remainder += response.base64Encoded ?
+          decoder.decode(Buffer.from(response.data, 'base64'), {stream: !isEof}) :
+          response.data;
+
+        // Perfetto's `ExportJson` serializes each trace event and trailing `metadata`
+        // as compact single-line JSON (with string newlines escaped as `\\n`), emitting
+        // raw `,\n` only between top-level elements of `traceEvents`.
+        // Maintain the invariant that `remainder` always starts with `{"traceEvents":[`.
+        const lastEventSep = remainder.lastIndexOf('},\n');
+        if (lastEventSep !== -1) {
+          const {traceEvents: batch} = JSON.parse(`${remainder.slice(0, lastEventSep + 1)}]}`);
+          for (const event of batch) {
+            traceEvents.push(event);
+          }
+          remainder = `{"traceEvents":[${remainder.slice(lastEventSep + 3)}`;
+        }
+      }
+    } finally {
+      await session.sendCommand('IO.close', {handle});
+    }
 
-    /**
-     * Listener for when dataCollected events fire for each trace chunk
-     * @param {LH.Crdp.Tracing.DataCollectedEvent} data
-     */
-    const dataListener = function(data) {
-      traceEvents.push(...data.value);
-    };
-    session.on('Tracing.dataCollected', dataListener);
-
-    return new Promise((resolve, reject) => {
-      session.once('Tracing.tracingComplete', _ => {
-        session.off('Tracing.dataCollected', dataListener);
-        resolve({traceEvents});
-      });
+    const traceJson = JSON.parse(remainder);
+    for (const event of traceJson.traceEvents) {
+      traceEvents.push(event);
+    }
+    traceJson.traceEvents = traceEvents;
+    return traceJson;
+  }
 
-      session.sendCommand('Tracing.end').catch(reject);
+  /**
+   * @param {LH.Gatherer.ProtocolSession} session
+   * @return {Promise<LH.Trace>}
+   */
+  static async endTraceAndCollectEvents(session) {
+    /** @type {LH.Crdp.Tracing.TracingCompleteEvent} */
+    const completeEvent = await new Promise((resolve, reject) => {
+      session.once('Tracing.tracingComplete', resolve);
+      session.sendCommand('Tracing.end').catch(err => {
+        session.off('Tracing.tracingComplete', resolve);
+        reject(err);
+      });
     });
+
+    if (!completeEvent.stream) {
+      throw new Error('Tracing.tracingComplete did not return a stream handle');
+    }
+
+    return Trace._readTraceFromStream(session, completeEvent.stream);
   }
 
   static symbol = Symbol('Trace');
@@ -115,6 +154,7 @@ class Trace extends BaseGatherer {
     await driver.defaultSession.sendCommand('Page.enable');
     await driver.defaultSession.sendCommand('Tracing.start', {
       categories: traceCategories.join(','),
+      transferMode: 'ReturnAsStream',
       options: 'sampling-frequency=10000', // 1000 is default and too slow.
     });
 

package/core/lib/network-request.js

@@ -345,6 +345,9 @@ class NetworkRequest {
     this.networkEndTime = data.timestamp * 1000;
 
     this._updateResponseHeadersEndTimeIfNecessary();
+    this._updateProtocolForLightrider();
+    this._updateTransferSizeForLightrider();
+    this._updateTimingsForLightrider();
   }
 
   /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "13.5.0-dev.20261021",
+  "version": "13.5.0-dev.20261022",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {

package/readme.md

@@ -112,7 +112,8 @@ Configuration:
 
 Output:
   --output       Reporter for the results, supports multiple values. choices: "json", "html", "csv"  [array] [default: ["html"]]
-  --output-path  The file path to output the results. Use 'stdout' to write to stdout.
+  --output-path  The file or directory path to output the results. Use 'stdout' to write to stdout.
+                   Directories in the path must already exist. If a directory is specified, the file name will be based on the test URL and date.
                    If using JSON output, default is stdout.
                    If using HTML or CSV output, default is a file in the working directory with a name based on the test URL and date.
                    If using multiple outputs, --output-path is appended with the standard extension for each output type. "reports/my-run" -> "reports/my-run.report.html", "reports/my-run.report.json", etc.