lighthouse 13.5.0-dev.20261021 → 13.5.0-dev.20261023

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.
@@ -327,7 +328,7 @@ Example: --output-path=./lighthouse-results.html`,
         if (
           typeof argv.outputPath === 'string' &&
           argv.outputPath &&
-          (!fs.existsSync(argv.outputPath) || !fs.lstatSync(argv.outputPath).isDirectory())
+          (!fs.existsSync(argv.outputPath) || !fs.statSync(argv.outputPath).isDirectory())
         ) {
           throw new Error('--output-path must be an existing directory when auditing multiple URLs');
         }
@@ -458,7 +459,7 @@ function coerceUrlFile(value) {
     typeof value !== 'string' ||
     !value ||
     !fs.existsSync(value) ||
-    fs.lstatSync(value).isDirectory()
+    fs.statSync(value).isDirectory()
   ) {
     throw new Error(`--url-file (${value}) cannot be read`);
   }

package/cli/run.js

@@ -149,7 +149,7 @@ async function saveResults(runnerResult, flags) {
   const isDirectoryOutput = Boolean(
     flags.outputPath &&
     fs.existsSync(flags.outputPath) &&
-    fs.lstatSync(flags.outputPath).isDirectory()
+    fs.statSync(flags.outputPath).isDirectory()
   );
 
   // Use the output path as the prefix for all generated files.

package/cli/test/smokehouse/smokehouse-test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=smokehouse-test.d.ts.map

package/cli/test/smokehouse/smokehouse-test.js

@@ -0,0 +1,120 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as td from 'testdouble';
+
+import {runSmokehouse} from './smokehouse.js';
+import {ChildProcessError} from './lib/child-process-error.js';
+
+/** @type {Smokehouse.TestDfn} */
+const smokeTestDefn = {
+  id: 'test-smoke',
+  expectations: {
+    lhr: {
+      requestedUrl: 'http://localhost:10200/simple-page.html',
+      finalDisplayedUrl: 'http://localhost:10200/simple-page.html',
+      audits: {},
+    },
+  },
+};
+
+describe('runSmokehouse error logging', () => {
+  /** @type {string[]} */
+  let loggedMessages;
+
+  beforeEach(() => {
+    loggedMessages = [];
+    td.replace(console, 'log', (/** @type {unknown[]} */ ...args) => {
+      loggedMessages.push(args.map(String).join(' '));
+    });
+  });
+
+  afterEach(() => {
+    td.reset();
+  });
+
+  it('logs runner logger output when lighthouseRunner returns a malformed result', async () => {
+    /** @type {Smokehouse.LighthouseRunner} */
+    // @ts-expect-error - testing malformed runner result
+    const lighthouseRunner = async (_url, _config, logger) => {
+      logger?.log('runner progress before malformed result');
+      return {lhr: {}, artifacts: undefined};
+    };
+
+    const {success, testResults} = await runSmokehouse([smokeTestDefn], {
+      lighthouseRunner,
+      retries: 0,
+    });
+
+    expect(success).toBe(false);
+    expect(testResults).toHaveLength(1);
+    expect(testResults[0].failed).toBe(1);
+
+    const combinedOutput = loggedMessages.join('\n');
+    expect(combinedOutput).toContain('lighthouse runner returned a bad result');
+    expect(combinedOutput).toContain('runner progress before malformed result');
+  });
+
+  it('logs runner logger output when lighthouseRunner throws a regular Error', async () => {
+    /** @type {Smokehouse.LighthouseRunner} */
+    const lighthouseRunner = async (_url, _config, logger) => {
+      logger?.log('runner progress before throwing');
+      throw new Error('unexpected runner failure');
+    };
+
+    const {success, testResults} = await runSmokehouse([smokeTestDefn], {
+      lighthouseRunner,
+      retries: 0,
+    });
+
+    expect(success).toBe(false);
+    expect(testResults).toHaveLength(1);
+    expect(testResults[0].failed).toBe(1);
+
+    const combinedOutput = loggedMessages.join('\n');
+    expect(combinedOutput).toContain('unexpected runner failure');
+    expect(combinedOutput).toContain('runner progress before throwing');
+  });
+
+  it('does not duplicate runner logger output for ChildProcessError', async () => {
+    /** @type {Smokehouse.LighthouseRunner} */
+    const lighthouseRunner = async (_url, _config, logger) => {
+      logger?.log('unique-cli-runner-log-line');
+      throw new ChildProcessError('Lighthouse run failed', logger?.getLog());
+    };
+
+    const {success} = await runSmokehouse([smokeTestDefn], {
+      lighthouseRunner,
+      retries: 0,
+    });
+
+    expect(success).toBe(false);
+
+    const combinedOutput = loggedMessages.join('\n');
+    const occurrences = combinedOutput.split('unique-cli-runner-log-line').length - 1;
+    expect(occurrences).toBe(1);
+  });
+
+  it('does not duplicate runner logger output when Error message already includes it', async () => {
+    /** @type {Smokehouse.LighthouseRunner} */
+    const lighthouseRunner = async (_url, _config, logger) => {
+      logger?.log('unique-worker-runner-log-line');
+      const log = logger?.getLog() || '';
+      throw new Error(`Worker returned an error: boom\nLog:\n${log}\n`);
+    };
+
+    const {success} = await runSmokehouse([smokeTestDefn], {
+      lighthouseRunner,
+      retries: 0,
+    });
+
+    expect(success).toBe(false);
+
+    const combinedOutput = loggedMessages.join('\n');
+    const occurrences = combinedOutput.split('unique-worker-runner-log-line').length - 1;
+    expect(occurrences).toBe(1);
+  });
+});

package/cli/test/smokehouse/smokehouse.js

@@ -190,10 +190,10 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
         clearTimeout(timeoutId);
       }
 
-      if (!timedResult.lhr?.audits || !timedResult.artifacts) {
+      if (!timedResult?.lhr?.audits || !timedResult.artifacts) {
         // Something went really wrong and the runner didn't catch it.
         throw new Error('lighthouse runner returned a bad result. got lhr:\n' +
-          JSON.stringify(timedResult.lhr, null, 2));
+          JSON.stringify(timedResult?.lhr, null, 2));
       }
 
       result = {
@@ -206,9 +206,17 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
       if (takeNetworkRequestUrls) takeNetworkRequestUrls();
 
       logChildProcessError(bufferedConsole, e);
+      const runnerLog = logger.getLog();
       if (isTimeout) {
         bufferedConsole.log('Timed out. log from lighthouseRunner:');
-        bufferedConsole.log(logger.getLog());
+        bufferedConsole.log(runnerLog);
+      } else if (
+        !(e instanceof ChildProcessError) &&
+        runnerLog &&
+        !e.message?.includes(runnerLog)
+      ) {
+        bufferedConsole.log('log from lighthouseRunner:');
+        bufferedConsole.log(runnerLog);
       }
       continue; // Retry, if possible.
     }

package/core/audits/script-treemap-data.js

@@ -178,21 +178,31 @@ class ScriptTreemapDataAudit extends Audit {
     const htmlNodesByFrameId = new Map();
     /** @type {Set<LH.Artifacts.NetworkRequest>} */
     const seenNetworkRecords = new Set();
-    const bundles = await JSBundles.request(artifacts, context);
-    const duplicationByPath = await ModuleDuplication.request(artifacts, context);
+    const deduplicatedScripts = artifacts.Scripts.filter(script => {
+      if (script.scriptLanguage !== 'JavaScript') return false;
 
-    for (const script of artifacts.Scripts) {
-      if (script.scriptLanguage !== 'JavaScript') continue;
-
-      const isInlineScript = isInline(script);
-      const networkRecord = isInlineScript ?
+      const networkRecord = isInline(script) ?
         undefined :
         getRequestForScript(networkRecords, script);
       if (networkRecord) {
-        if (seenNetworkRecords.has(networkRecord)) continue;
+        if (seenNetworkRecords.has(networkRecord)) return false;
         seenNetworkRecords.add(networkRecord);
       }
 
+      return true;
+    });
+    const deduplicatedArtifacts = deduplicatedScripts.length === artifacts.Scripts.length ?
+      artifacts :
+      {...artifacts, Scripts: deduplicatedScripts};
+    const bundles = await JSBundles.request(deduplicatedArtifacts, context);
+    const duplicationByPath = await ModuleDuplication.request(deduplicatedArtifacts, context);
+
+    for (const script of deduplicatedScripts) {
+      const isInlineScript = isInline(script);
+      const networkRecord = isInlineScript ?
+        undefined :
+        getRequestForScript(networkRecords, script);
+
       const name = script.url;
       const bundle = bundles.find(bundle => script.scriptId === bundle.script.scriptId) ?? null;
       const scriptCoverage = /** @type {LH.Artifacts['JsUsage'][string] | undefined} */

package/core/computed/metrics/lantern-metric.js

@@ -40,7 +40,7 @@ async function getComputationDataParamsFromTrace(data, context) {
   const traceEngineResult = await TraceEngineResult.request(data, context);
   const frameId = traceEngineResult.data.Meta.mainFrameId;
   const navigation =
-    traceEngineResult.data.Meta.mainFrameNavigations[0];
+    traceEngineResult.data.Meta.mainFrameNavigations.at(-1);
   if (!navigation) {
     throw new Error(`Lantern metrics could not be calculated due to missing navigation id`);
   }

package/core/computed/page-dependency-graph.js

@@ -11,6 +11,26 @@ import {ProcessedTrace} from './processed-trace.js';
 import {NetworkRecords} from './network-records.js';
 import {TraceEngineResult} from './trace-engine-result.js';
 
+/**
+ * ResourceSendRequest URLs in the trace retain #hash fragments, whereas CDP
+ * Network.requestWillBeSent, Page.frameNavigated, initiator.url, documentURL,
+ * and V8 script events strip #hash fragments, and Lantern's NetworkAnalyzer
+ * requires request.url not to have a fragment.
+ * TODO: Remove once @paulirish/trace_engine includes the fix in LanternComputationData.
+ * @param {string} urlStr
+ * @return {string}
+ */
+function stripUrlHash(urlStr) {
+  if (!urlStr.includes('#')) return urlStr;
+  try {
+    const url = new URL(urlStr);
+    url.hash = '';
+    return url.href;
+  } catch {
+    return urlStr;
+  }
+}
+
 class PageDependencyGraph {
   /**
    * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings'], URL: LH.Artifacts['URL'], SourceMaps: LH.Artifacts['SourceMaps'], HostDPR: LH.Artifacts['HostDPR'], fromTrace: boolean}} data
@@ -27,7 +47,41 @@ class PageDependencyGraph {
     if (data.fromTrace) {
       const traceEngineResult =
         await TraceEngineResult.request({trace, settings, SourceMaps, HostDPR}, context);
-      const parsedTrace = traceEngineResult.data;
+      let parsedTrace = traceEngineResult.data;
+      if (parsedTrace.NetworkRequests.byTime.some(
+        r => r.args.data.url.includes('#') ||
+          r.args.data.redirects.some(red => red.url.includes('#'))
+      )) {
+        const byTime = parsedTrace.NetworkRequests.byTime.map(request => {
+          const url = stripUrlHash(request.args.data.url);
+          const redirects = request.args.data.redirects.map(redirect => ({
+            ...redirect,
+            url: stripUrlHash(redirect.url),
+          }));
+          if (url === request.args.data.url &&
+              redirects.every((red, i) => red.url === request.args.data.redirects[i].url)) {
+            return request;
+          }
+          return {
+            ...request,
+            args: {
+              ...request.args,
+              data: {
+                ...request.args.data,
+                url,
+                redirects,
+              },
+            },
+          };
+        });
+        parsedTrace = {
+          ...parsedTrace,
+          NetworkRequests: {
+            ...parsedTrace.NetworkRequests,
+            byTime,
+          },
+        };
+      }
       const requests =
         Lantern.TraceEngineComputationData.createNetworkRequests(trace, parsedTrace);
       const graph =

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/arbitrary-equality-map.d.ts

@@ -50,9 +50,9 @@ export class ArbitraryEqualityMap {
 /**
  * @param {*} a
  * @param {*} b
- * @param {WeakMap<object, object>=} seen
+ * @param {WeakMap<object, WeakSet<object>>=} seen
  * @return {boolean}
  */
-declare function deepEquals(a: any, b: any, seen?: WeakMap<object, object> | undefined): boolean;
+declare function deepEquals(a: any, b: any, seen?: WeakMap<object, WeakSet<object>> | undefined): boolean;
 export { deepEquals as isEqual };
 //# sourceMappingURL=arbitrary-equality-map.d.ts.map

package/core/lib/arbitrary-equality-map.js

@@ -7,7 +7,7 @@
 /**
  * @param {*} a
  * @param {*} b
- * @param {WeakMap<object, object>=} seen
+ * @param {WeakMap<object, WeakSet<object>>=} seen
  * @return {boolean}
  */
 function deepEquals(a, b, seen) {
@@ -32,13 +32,27 @@ function deepEquals(a, b, seen) {
     }
     return true;
   }
+  if (a instanceof ArrayBuffer && b instanceof ArrayBuffer) {
+    if (a.byteLength !== b.byteLength) return false;
+    const viewA = new Uint8Array(a);
+    const viewB = new Uint8Array(b);
+    for (let i = 0; i < viewA.length; i++) {
+      if (viewA[i] !== viewB[i]) return false;
+    }
+    return true;
+  }
 
-  if (seen) {
-    if (seen.get(a) === b) return true;
-  } else {
+  if (!seen) {
     seen = new WeakMap();
   }
-  seen.set(a, b);
+  let seenB = seen.get(a);
+  if (seenB) {
+    if (seenB.has(b)) return true;
+  } else {
+    seenB = new WeakSet();
+    seen.set(a, seenB);
+  }
+  seenB.add(b);
 
   if (Array.isArray(a)) {
     const arrB = /** @type {unknown[]} */ (b);
@@ -59,12 +73,38 @@ function deepEquals(a, b, seen) {
 
   if (a instanceof Set && b instanceof Set) {
     if (a.size !== b.size) return false;
+    /** @type {unknown[]} */
+    const unmatchedA = [];
     for (const v of a) {
-      if (!b.has(v)) return false;
+      if (!b.has(v)) {
+        if (typeof v !== 'object' || v === null) return false;
+        unmatchedA.push(v);
+      }
+    }
+    if (unmatchedA.length === 0) return true;
+    /** @type {unknown[]} */
+    const unmatchedB = [];
+    for (const v of b) {
+      if (!a.has(v)) {
+        if (typeof v !== 'object' || v === null) return false;
+        unmatchedB.push(v);
+      }
+    }
+    if (unmatchedA.length !== unmatchedB.length) return false;
+    for (const itemA of unmatchedA) {
+      const matchIndex = unmatchedB.findIndex(itemB => deepEquals(itemA, itemB, seen));
+      if (matchIndex === -1) return false;
+      unmatchedB.splice(matchIndex, 1);
     }
     return true;
   }
 
+  if (a instanceof Error && b instanceof Error) {
+    if (a.name !== b.name || a.message !== b.message || !deepEquals(a.cause, b.cause, seen)) {
+      return false;
+    }
+  }
+
   const keysA = Object.keys(a);
   const keysB = Object.keys(b);
   if (keysA.length !== keysB.length) return false;

package/core/lib/legacy-javascript/legacy-javascript.js

@@ -189,8 +189,8 @@ function getPolyfillPatterns() {
   // 4. es-shims: `no(Object,{entries:r},{entries:function`
   const esShimsBranches = [];
   for (const [object, props] of byObject) {
-    const propAlt = `(?:${props.join('|')})`;
-    esShimsBranches.push(`${escapeRegExp(object)},\\s*{${propAlt}:.*},\\s*{${propAlt}`);
+    const propBranches = props.map(p => `${p}:[^};]*},\\s*{${p}\\b`).join('|');
+    esShimsBranches.push(`${escapeRegExp(object)},\\s*{(?:${propBranches})`);
   }
 
   // 5. core-js@3 minified pattern:

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();
   }
 
   /**