lighthouse 13.5.0-dev.20261022 → 13.5.0-dev.20261023

package/cli/cli-flags.js

@@ -328,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');
         }
@@ -459,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/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: