lighthouse 13.5.0 → 13.6.0-dev.20261028

package/core/config/constants.d.ts

@@ -1,31 +1,4 @@
-export const throttling: {
-    DEVTOOLS_RTT_ADJUSTMENT_FACTOR: number;
-    DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR: number;
-    mobileSlow4G: {
-        rttMs: number;
-        throughputKbps: number;
-        requestLatencyMs: number;
-        downloadThroughputKbps: number;
-        uploadThroughputKbps: number;
-        cpuSlowdownMultiplier: number;
-    };
-    mobileRegular3G: {
-        rttMs: number;
-        throughputKbps: number;
-        requestLatencyMs: number;
-        downloadThroughputKbps: number;
-        uploadThroughputKbps: number;
-        cpuSlowdownMultiplier: number;
-    };
-    desktopDense4G: {
-        rttMs: number;
-        throughputKbps: number;
-        cpuSlowdownMultiplier: number;
-        requestLatencyMs: number;
-        downloadThroughputKbps: number;
-        uploadThroughputKbps: number;
-    };
-};
+export const throttling: Lantern.Simulation.ThrottlingSettings;
 export namespace screenEmulationMetrics {
     export { MOTOGPOWER_EMULATION_METRICS as mobile };
     export { DESKTOP_EMULATION_METRICS as desktop };
@@ -42,6 +15,7 @@ export namespace nonSimulatedSettingsOverrides {
     let networkQuietThresholdMs: number;
     let cpuQuietThresholdMs: number;
 }
+import * as Lantern from '../lib/lantern/lantern.js';
 /**
  * @type {Required<LH.SharedFlagsSettings['screenEmulation']>}
  */

package/core/config/filters.js

@@ -69,6 +69,7 @@ function filterArtifactsByAvailableAudits(artifacts, audits) {
   /** @type {Set<string>} */
   const artifactIdsToKeep = new Set([
     ...filterResistantArtifactIds,
+    ...artifacts.filter(artifact => artifact.alwaysGather).map(artifact => artifact.id),
     ...audits.flatMap(audit => audit.implementation.meta.requiredArtifacts),
   ]);
 

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/base-artifacts.js

@@ -5,12 +5,13 @@
  */
 
 import log from 'lighthouse-logger';
-import {isEqual} from 'lodash-es';
 
 import {
   getBrowserVersion, getBenchmarkIndex, getEnvironmentWarnings,
   getDevicePixelRatio,
 } from './driver/environment.js';
+import {isEqual} from '../lib/arbitrary-equality-map.js';
+import {Sentry} from '../lib/sentry.js';
 
 /**
  * @param {LH.Config.ResolvedConfig} resolvedConfig
@@ -23,6 +24,11 @@ async function getBaseArtifacts(resolvedConfig, driver, context) {
   const {userAgent, product} = await getBrowserVersion(driver.defaultSession);
   const HostDPR = await getDevicePixelRatio(driver.executionContext);
 
+  const [name, version] = product.split('/');
+  if (name && version) {
+    Sentry.setContext('browser', {name, version});
+  }
+
   return {
     // Meta artifacts.
     fetchTime: new Date().toJSON(),

package/core/gather/driver/storage.js

@@ -41,13 +41,14 @@ const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
  * @return {Promise<LH.IcuMessage[]>}
  */
 async function clearDataForOrigin(session, url, clearStorageTypes) {
+  const origin = new URL(url).origin;
+  if (origin === 'null') return [];
+
   const status = {msg: 'Cleaning origin data', id: 'lh:storage:clearDataForOrigin'};
   log.time(status);
 
   const warnings = [];
 
-  const origin = new URL(url).origin;
-
   const typesToClear = clearStorageTypes.join(',');
 
   // `Storage.clearDataForOrigin` is one of our PROTOCOL_TIMEOUT culprits and this command is also

package/core/gather/gatherers/agentic/ard.d.ts

@@ -1,26 +1,81 @@
 export default AgentResourceDiscovery;
+export type ArdLinks = {
+    ard: string | null;
+    legacy: string | null;
+};
+export type DiscoverySignals = LH.Artifacts["AgentResourceDiscovery"]["discoverySignals"];
+export type FetchResult = {
+    status: number | null;
+    content: string | null;
+    headers: Record<string, string> | null;
+    errorMessage?: string | undefined;
+};
+/**
+ * A location to try when resolving the manifest. `advertised` locations are ones the site
+ * points at (robots.txt, link tags, Link headers); the well-known paths are probed by
+ * Lighthouse, so a failure there is not the site's fault and is not reported.
+ */
+export type ManifestCandidate = {
+    source: LH.Artifacts.ArdDiscoverySource;
+    url: string | null;
+    advertised: boolean;
+};
 declare class AgentResourceDiscovery extends BaseGatherer {
     /**
+     * Returns the absolute URL from the first `Agentmap:` directive in robots.txt, if any.
      * @param {LH.Artifacts['RobotsTxt']|null|undefined} robotsTxt
      * @param {string} finalDisplayedUrl
      * @return {string|null}
      */
     static getRobotsTxtAgentmap(robotsTxt: LH.Artifacts["RobotsTxt"] | null | undefined, finalDisplayedUrl: string): string | null;
     /**
+     * Finds `<link rel="ard">` and `<link rel="ai-catalog">` in the page.
      * @param {LH.Gatherer.Context} context
      * @param {string} finalDisplayedUrl
-     * @return {Promise<string|null>}
+     * @return {Promise<ArdLinks>}
      */
-    static getHtmlLinkFromDom(context: LH.Gatherer.Context, finalDisplayedUrl: string): Promise<string | null>;
+    static getHtmlLinksFromDom(context: LH.Gatherer.Context, finalDisplayedUrl: string): Promise<ArdLinks>;
     /**
+     * Finds `rel="ard"` and `rel="ai-catalog"` in the main document's HTTP `Link` header.
      * @param {LH.Gatherer.Context} context
      * @param {string} finalDisplayedUrl
-     * @return {Promise<string|null>}
+     * @return {Promise<ArdLinks>}
      */
-    static getHttpHeaderLink(context: LH.Gatherer.Context, finalDisplayedUrl: string): Promise<string | null>;
+    static getHttpHeaderLinks(context: LH.Gatherer.Context, finalDisplayedUrl: string): Promise<ArdLinks>;
+    /**
+     * Fetches a candidate manifest URL. Never throws; network errors are returned as a
+     * null status with an `errorMessage`.
+     * @param {LH.Gatherer.Context} context
+     * @param {string} url
+     * @return {Promise<FetchResult>}
+     */
+    static fetchManifest(context: LH.Gatherer.Context, url: string): Promise<FetchResult>;
+    /**
+     * Tries each candidate in order and returns the first that loads. Advertised candidates
+     * that fail are recorded in `failedSources` and skipped. If nothing loads, the result
+     * describes the first advertised location that failed, or else the `/.well-known/ard.json`
+     * path consumers are required to fetch.
+     * @param {LH.Gatherer.Context} context
+     * @param {ManifestCandidate[]} candidates
+     * @return {Promise<{
+     *   discoverySource: LH.Artifacts.ArdDiscoverySource,
+     *   catalogUrl: string,
+     *   fetchResult: FetchResult,
+     *   failedSources: LH.Artifacts['AgentResourceDiscovery']['failedSources'],
+     * }>}
+     */
+    static resolveManifest(context: LH.Gatherer.Context, candidates: ManifestCandidate[]): Promise<{
+        discoverySource: LH.Artifacts.ArdDiscoverySource;
+        catalogUrl: string;
+        fetchResult: FetchResult;
+        failedSources: LH.Artifacts["AgentResourceDiscovery"]["failedSources"];
+    }>;
     /** @type {LH.Gatherer.GathererMeta<'RobotsTxt'>} */
     meta: LH.Gatherer.GathererMeta<"RobotsTxt">;
     /**
+     * Resolves the manifest following ARD §5.1: explicit ARD signals first, then the
+     * `/.well-known/ard.json` path consumers MUST fetch, and only then the predecessor
+     * `ai-catalog` relation and well-known path, which consumers MAY consult.
      * @param {LH.Gatherer.Context<'RobotsTxt'>} context
      * @return {Promise<LH.Artifacts['AgentResourceDiscovery']>}
      */

package/core/gather/gatherers/agentic/ard.js

@@ -4,17 +4,112 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/**
+ * @fileoverview Gatherer that discovers and fetches a site's Agentic Resource Discovery (ARD)
+ * manifest. It follows the discovery mechanisms in ARD §5.1 and also consults the predecessor
+ * `ai-catalog` names so that sites that have not yet migrated are still audited.
+ * @see https://agenticresourcediscovery.org/spec/
+ */
+
 import log from 'lighthouse-logger';
 import LinkHeader from 'http-link-header';
 
 import BaseGatherer from '../../base-gatherer.js';
 import RobotsTxt from '../seo/robots-txt.js';
-import {pageFunctions} from '../../../lib/page-functions.js';
-function getAiCatalogLinkInDOM() {
-  const link = document.querySelector('link[rel~="ai-catalog" i]');
-  return link instanceof HTMLLinkElement ? link.href : null;
+
+/**
+ * Link relations for ARD entry sources. `ai-catalog` is the predecessor relation, which
+ * consumers MAY consult but are not required to (ARD §5.1).
+ */
+const REL_ARD = 'ard';
+const REL_LEGACY = 'ai-catalog';
+
+const WELL_KNOWN_PATH = '/.well-known/ard.json';
+const LEGACY_WELL_KNOWN_PATH = '/.well-known/ai-catalog.json';
+
+const HTTP_OK = 200;
+
+/** @typedef {{ard: string|null, legacy: string|null}} ArdLinks */
+
+/** @typedef {LH.Artifacts['AgentResourceDiscovery']['discoverySignals']} DiscoverySignals */
+
+/**
+ * @typedef FetchResult
+ * @property {number|null} status
+ * @property {string|null} content
+ * @property {Record<string, string>|null} headers
+ * @property {string} [errorMessage]
+ */
+
+/**
+ * A location to try when resolving the manifest. `advertised` locations are ones the site
+ * points at (robots.txt, link tags, Link headers); the well-known paths are probed by
+ * Lighthouse, so a failure there is not the site's fault and is not reported.
+ * @typedef ManifestCandidate
+ * @property {LH.Artifacts.ArdDiscoverySource} source
+ * @property {string|null} url
+ * @property {boolean} advertised
+ */
+
+/** @type {ReadonlyArray<LH.Artifacts.ArdDiscoverySource>} */
+const SOURCE_PRIORITY = [
+  'robotsTxtAgentmap',
+  'htmlLink',
+  'httpHeaderLink',
+  'wellKnown',
+  'legacyHtmlLink',
+  'legacyHttpHeaderLink',
+  'legacyWellKnown',
+];
+
+/** @type {Set<LH.Artifacts.ArdDiscoverySource>} */
+const PROBED_SOURCES = new Set(['wellKnown', 'legacyWellKnown']);
+
+/**
+ * @param {DiscoverySignals} discoverySignals
+ * @return {ManifestCandidate[]}
+ */
+function getManifestCandidates(discoverySignals) {
+  return SOURCE_PRIORITY.map(source => ({
+    source,
+    url: discoverySignals[source],
+    advertised: !PROBED_SOURCES.has(source),
+  }));
+}
+
+/**
+ * Resolves `href` against `baseUrl`, returning null for empty or unparseable values.
+ * @param {string|null|undefined} href
+ * @param {string} baseUrl
+ * @return {string|null}
+ */
+function resolveUrl(href, baseUrl) {
+  if (!href) return null;
+  try {
+    return new URL(href, baseUrl).href;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Runs in the page. Returns the `href` of the first `<link>` for each relation, or null.
+ * @param {string} relArd
+ * @param {string} relLegacy
+ * @return {ArdLinks}
+ */
+function getArdLinksInDOM(relArd, relLegacy) {
+  /** @param {string} rel */
+  const getHref = rel => {
+    const link = document.querySelector(`link[rel~="${rel}" i]`);
+    return link instanceof HTMLLinkElement ? link.href : null;
+  };
+  return {ard: getHref(relArd), legacy: getHref(relLegacy)};
 }
 
+/** @type {ArdLinks} */
+const NO_LINKS = {ard: null, legacy: null};
+
 class AgentResourceDiscovery extends BaseGatherer {
   /** @type {LH.Gatherer.GathererMeta<'RobotsTxt'>} */
   meta = {
@@ -23,6 +118,7 @@ class AgentResourceDiscovery extends BaseGatherer {
   };
 
   /**
+   * Returns the absolute URL from the first `Agentmap:` directive in robots.txt, if any.
    * @param {LH.Artifacts['RobotsTxt']|null|undefined} robotsTxt
    * @param {string} finalDisplayedUrl
    * @return {string|null}
@@ -31,93 +127,159 @@ class AgentResourceDiscovery extends BaseGatherer {
     if (!robotsTxt?.content) return null;
     const match = robotsTxt.content.match(/^\s*Agentmap:\s*(\S+)/im);
     if (!match) return null;
-    try {
-      return new URL(match[1], finalDisplayedUrl).href;
-    } catch {
-      return null;
-    }
+    return resolveUrl(match[1], finalDisplayedUrl);
   }
 
   /**
+   * Finds `<link rel="ard">` and `<link rel="ai-catalog">` in the page.
    * @param {LH.Gatherer.Context} context
    * @param {string} finalDisplayedUrl
-   * @return {Promise<string|null>}
+   * @return {Promise<ArdLinks>}
    */
-  static async getHtmlLinkFromDom(context, finalDisplayedUrl) {
+  static async getHtmlLinksFromDom(context, finalDisplayedUrl) {
     try {
-      const href = await context.driver.executionContext.evaluate(getAiCatalogLinkInDOM, {
-        args: [],
+      const links = await context.driver.executionContext.evaluate(getArdLinksInDOM, {
+        args: [REL_ARD, REL_LEGACY],
         useIsolation: true,
-        deps: [pageFunctions.getNodeDetails],
       });
-      if (!href) return null;
-      return new URL(href, finalDisplayedUrl).href;
-    } catch {
-      return null;
+      return {
+        ard: resolveUrl(links?.ard, finalDisplayedUrl),
+        legacy: resolveUrl(links?.legacy, finalDisplayedUrl),
+      };
+    } catch (err) {
+      log.verbose('AgentResourceDiscovery', `Could not read link tags: ${err.message}`);
+      return NO_LINKS;
     }
   }
 
   /**
+   * Finds `rel="ard"` and `rel="ai-catalog"` in the main document's HTTP `Link` header.
    * @param {LH.Gatherer.Context} context
    * @param {string} finalDisplayedUrl
-   * @return {Promise<string|null>}
+   * @return {Promise<ArdLinks>}
    */
-  static async getHttpHeaderLink(context, finalDisplayedUrl) {
-    // Only check in navigation mode
-    if (context.gatherMode !== 'navigation') return null;
+  static async getHttpHeaderLinks(context, finalDisplayedUrl) {
+    if (context.gatherMode !== 'navigation') return NO_LINKS;
 
     try {
       const mainResourceResponse = await context.driver.fetcher.fetchResource(finalDisplayedUrl);
-      const linkHeader = mainResourceResponse.headers?.['link'];
-      if (!linkHeader) return null;
+      const linkHeader = mainResourceResponse.headers?.link;
+      if (!linkHeader) return NO_LINKS;
+
+      const parsed = LinkHeader.parse(linkHeader.replace(/\n/g, ','));
+      /** @param {string} rel */
+      const getUri = rel =>
+        resolveUrl(parsed.refs.find(ref => ref.rel?.toLowerCase() === rel)?.uri, finalDisplayedUrl);
+      return {ard: getUri(REL_ARD), legacy: getUri(REL_LEGACY)};
+    } catch (err) {
+      log.verbose('AgentResourceDiscovery', `Could not read Link header: ${err.message}`);
+      return NO_LINKS;
+    }
+  }
+
+  /**
+   * Fetches a candidate manifest URL. Never throws; network errors are returned as a
+   * null status with an `errorMessage`.
+   * @param {LH.Gatherer.Context} context
+   * @param {string} url
+   * @return {Promise<FetchResult>}
+   */
+  static async fetchManifest(context, url) {
+    try {
+      const {status, content, headers} = await context.driver.fetcher.fetchResource(url);
+      return {status, content, headers: headers || null};
+    } catch (err) {
+      log.error('AgentResourceDiscovery', err);
+      return {status: null, content: null, headers: null, errorMessage: err.message};
+    }
+  }
 
-      const parsed = LinkHeader.parse(linkHeader);
-      const aiCatalogRef = parsed.get('rel', 'ai-catalog')[0];
-      if (!aiCatalogRef?.uri) return null;
+  /**
+   * Tries each candidate in order and returns the first that loads. Advertised candidates
+   * that fail are recorded in `failedSources` and skipped. If nothing loads, the result
+   * describes the first advertised location that failed, or else the `/.well-known/ard.json`
+   * path consumers are required to fetch.
+   * @param {LH.Gatherer.Context} context
+   * @param {ManifestCandidate[]} candidates
+   * @return {Promise<{
+   *   discoverySource: LH.Artifacts.ArdDiscoverySource,
+   *   catalogUrl: string,
+   *   fetchResult: FetchResult,
+   *   failedSources: LH.Artifacts['AgentResourceDiscovery']['failedSources'],
+   * }>}
+   */
+  static async resolveManifest(context, candidates) {
+    /** @type {Array<{source: LH.Artifacts.ArdDiscoverySource, url: string, advertised: boolean, fetchResult: FetchResult}>} */
+    const attempts = [];
+    const failedSources = () => attempts
+      .filter(attempt => attempt.advertised)
+      .map(({source, url, fetchResult}) => ({
+        source,
+        url,
+        status: fetchResult.status,
+        errorMessage: fetchResult.errorMessage,
+      }));
+
+    for (const {source, url, advertised} of candidates) {
+      if (!url || attempts.some(attempt => attempt.url === url)) continue;
 
-      return new URL(aiCatalogRef.uri, finalDisplayedUrl).href;
-    } catch {
-      return null;
+      const fetchResult = await AgentResourceDiscovery.fetchManifest(context, url);
+      if (fetchResult.status === HTTP_OK && fetchResult.content) {
+        return {discoverySource: source, catalogUrl: url, fetchResult,
+          failedSources: failedSources()};
+      }
+      attempts.push({source, url, advertised, fetchResult});
     }
+
+    const fallback = attempts.find(attempt => attempt.advertised) ||
+      attempts.find(attempt => attempt.source === 'wellKnown');
+    if (!fallback) throw new Error('ARD discovery attempted no candidates');
+
+    return {
+      discoverySource: fallback.source,
+      catalogUrl: fallback.url,
+      fetchResult: fallback.fetchResult,
+      failedSources: failedSources(),
+    };
   }
 
   /**
+   * Resolves the manifest following ARD §5.1: explicit ARD signals first, then the
+   * `/.well-known/ard.json` path consumers MUST fetch, and only then the predecessor
+   * `ai-catalog` relation and well-known path, which consumers MAY consult.
    * @param {LH.Gatherer.Context<'RobotsTxt'>} context
    * @return {Promise<LH.Artifacts['AgentResourceDiscovery']>}
    */
   async getArtifact(context) {
     const {finalDisplayedUrl} = context.baseArtifacts.URL;
-    const robotsTxt = context.dependencies.RobotsTxt;
     const robotsTxtAgentmap = AgentResourceDiscovery.getRobotsTxtAgentmap(
-      robotsTxt, finalDisplayedUrl);
-    const [htmlLink, httpHeaderLink] = await Promise.all([
-      AgentResourceDiscovery.getHtmlLinkFromDom(context, finalDisplayedUrl),
-      AgentResourceDiscovery.getHttpHeaderLink(context, finalDisplayedUrl),
+      context.dependencies.RobotsTxt, finalDisplayedUrl);
+    const [htmlLinks, httpHeaderLinks] = await Promise.all([
+      AgentResourceDiscovery.getHtmlLinksFromDom(context, finalDisplayedUrl),
+      AgentResourceDiscovery.getHttpHeaderLinks(context, finalDisplayedUrl),
     ]);
-    const wellKnown = new URL('/.well-known/ai-catalog.json', finalDisplayedUrl).href;
-    const catalogUrl = robotsTxtAgentmap || htmlLink || httpHeaderLink || wellKnown;
-
-    /** @type {string|undefined} */
-    let errorMessage;
-    const fetchResult = await context.driver.fetcher.fetchResource(catalogUrl)
-      .catch(err => {
-        log.error('AgentResourceDiscovery', err);
-        errorMessage = err.message;
-        return {status: null, content: null, headers: null};
-      });
+
+    /** @type {DiscoverySignals} */
+    const discoverySignals = {
+      robotsTxtAgentmap,
+      htmlLink: htmlLinks.ard,
+      httpHeaderLink: httpHeaderLinks.ard,
+      legacyHtmlLink: htmlLinks.legacy,
+      legacyHttpHeaderLink: httpHeaderLinks.legacy,
+      wellKnown: new URL(WELL_KNOWN_PATH, finalDisplayedUrl).href,
+      legacyWellKnown: new URL(LEGACY_WELL_KNOWN_PATH, finalDisplayedUrl).href,
+    };
+
+    const candidates = getManifestCandidates(discoverySignals);
+    const {discoverySource, catalogUrl, fetchResult, failedSources} =
+      await AgentResourceDiscovery.resolveManifest(context, candidates);
 
     return {
-      status: fetchResult.status,
-      content: fetchResult.content,
-      headers: fetchResult.headers || null,
+      ...fetchResult,
       catalogUrl,
-      discoverySignals: {
-        robotsTxtAgentmap,
-        htmlLink,
-        httpHeaderLink,
-        wellKnown,
-      },
-      errorMessage,
+      discoverySource,
+      discoverySignals,
+      failedSources,
     };
   }
 }

package/core/gather/gatherers/full-page-screenshot.js

@@ -95,7 +95,7 @@ class FullPageScreenshot extends BaseGatherer {
       mobile: deviceMetrics.mobile,
       deviceScaleFactor: 1,
       height,
-      width: 0, // Leave width unchanged
+      width: deviceMetrics.width,
     });
 
     // Now that the viewport is taller, give the page some time to fetch new resources that
@@ -235,7 +235,7 @@ class FullPageScreenshot extends BaseGatherer {
             mobile: deviceMetrics.mobile,
             deviceScaleFactor: deviceMetrics.deviceScaleFactor,
             height: deviceMetrics.height,
-            width: 0, // Leave width unchanged
+            width: deviceMetrics.width,
           });
         }
       }

package/core/gather/gatherers/image-elements.d.ts

@@ -1,5 +1,12 @@
 export default ImageElements;
 declare class ImageElements extends BaseGatherer {
+    /**
+     * An img size attribute prevents layout shifts if it is a non-negative integer (incl zero!).
+     * @url https://html.spec.whatwg.org/multipage/embedded-content-other.html#dimension-attributes
+     * @param {string | null} attrValue
+     * @return {boolean}
+     */
+    static doesHtmlAttrProvideExplicitSize(attrValue: string | null): boolean;
     /** @type {Map<string, {naturalWidth: number, naturalHeight: number}>} */
     _naturalSizeCache: Map<string, {
         naturalWidth: number;