lighthouse 13.1.0 → 13.3.0

package/core/config/default-config.js

@@ -100,6 +100,21 @@ const UIStrings = {
   bestPracticesBrowserCompatGroupTitle: 'Browser Compatibility',
   /** Title of the General group of the Best Practices category. Within this section are the audits that don't belong to a specific group but are of general interest. */
   bestPracticesGeneralGroupTitle: 'General',
+  /** Title of the Agentic Browsing category of audits. */
+  agenticBrowsingCategoryTitle: 'Agentic Browsing',
+  /** Description of the Agentic Browsing category. */
+  agenticBrowsingCategoryDescription: 'These checks ensure high-quality, [browsable websites for AI agents](https://goo.gle/lighthouse-agentic-web) ' +
+  'and validate the correctness of WebMCP integrations. ' +
+  'This category is still under development and subject to change.',
+  /** Title of the WebMCP group of audits. */
+  webmcpGroupTitle: 'WebMCP',
+  /** Description of the WebMCP group. */
+  webmcpGroupDescription: 'Audits validating WebMCP integration.',
+  /** Title of the Agent Accessibility group of audits. */
+  agentAccessibilityGroupTitle: 'Agent Accessibility',
+  /** Description of the Agent Accessibility group of audits. */
+  agentAccessibilityGroupDescription: 'These audits highlight best practices for improving the ' +
+  'accessibility of the website for AI agents.',
 };
 
 const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
@@ -108,6 +123,9 @@ const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
 const defaultConfig = {
   settings: constants.defaultSettings,
   artifacts: [
+    {id: 'WebMCP', gatherer: 'webmcp'},
+    {id: 'WebMcpSchemaIssues', gatherer: 'webmcp-schema'},
+    {id: 'LlmsTxt', gatherer: 'agentic/llms-txt'},
     // Artifacts which can be depended on come first.
     {id: 'DevtoolsLog', gatherer: 'devtools-log'},
     {id: 'Trace', gatherer: 'trace'},
@@ -254,6 +272,9 @@ const defaultConfig = {
     'accessibility/manual/offscreen-content-hidden',
     'accessibility/manual/use-landmarks',
     'accessibility/manual/visual-order-follows-dom',
+    'accessibility/autocomplete-valid',
+    'accessibility/presentation-role-conflict',
+    'accessibility/svg-img-alt',
     'byte-efficiency/total-byte-weight',
     'byte-efficiency/unminified-css',
     'byte-efficiency/unminified-javascript',
@@ -276,6 +297,11 @@ const defaultConfig = {
     'seo/hreflang',
     'seo/canonical',
     'seo/manual/structured-data',
+    'agentic/agent-accessibility-tree',
+    'webmcp-registered-tools',
+    'webmcp-form-coverage',
+    'webmcp-schema-validity',
+    'agentic/llms-txt',
     'bf-cache',
     'insights/cache-insight',
     'insights/cls-culprits-insight',
@@ -363,6 +389,14 @@ const defaultConfig = {
     'best-practices-general': {
       title: str_(UIStrings.bestPracticesGeneralGroupTitle),
     },
+    'webmcp': {
+      title: str_(UIStrings.webmcpGroupTitle),
+      description: str_(UIStrings.webmcpGroupDescription),
+    },
+    'agent-accessibility': {
+      title: str_(UIStrings.agentAccessibilityGroupTitle),
+      description: str_(UIStrings.agentAccessibilityGroupDescription),
+    },
     // Group for audits that should not be displayed.
     'hidden': {title: ''},
   },
@@ -515,6 +549,9 @@ const defaultConfig = {
         {id: 'valid-lang', weight: 7, group: 'a11y-language'}, // Serious, wcag2aa
         {id: 'video-caption', weight: 10, group: 'a11y-audio-video'}, // Critical, wcag2a
         {id: 'landmark-one-main', weight: 3, group: 'a11y-best-practices'}, // Moderate, best-practice
+        {id: 'autocomplete-valid', weight: 1, group: 'a11y-best-practices'}, // Informational
+        {id: 'presentation-role-conflict', weight: 1, group: 'a11y-best-practices'}, // Informational
+        {id: 'svg-img-alt', weight: 1, group: 'a11y-best-practices'}, // Informational
         // Manual audits
         {id: 'focusable-controls', weight: 0},
         {id: 'interactive-element-affordance', weight: 0},
@@ -595,6 +632,20 @@ const defaultConfig = {
         {id: 'structured-data', weight: 0},
       ],
     },
+    'agentic-browsing': {
+      title: str_(UIStrings.agenticBrowsingCategoryTitle),
+      description: str_(UIStrings.agenticBrowsingCategoryDescription),
+      supportedModes: ['navigation', 'snapshot'],
+      categoryScoreDisplayMode: 'fraction',
+      auditRefs: [
+        {id: 'agent-accessibility-tree', weight: 1, group: 'agent-accessibility'},
+        {id: 'webmcp-form-coverage', weight: 1, group: 'webmcp'},
+        {id: 'webmcp-registered-tools', weight: 1, group: 'webmcp'},
+        {id: 'webmcp-schema-validity', weight: 1, group: 'webmcp'},
+        {id: 'cumulative-layout-shift', weight: 1, acronym: 'CLS'},
+        {id: 'llms-txt', weight: 1, group: 'agent-accessibility'},
+      ],
+    },
   },
 };
 

package/core/gather/gatherers/accessibility.js

@@ -50,6 +50,7 @@ async function runA11yChecks() {
       'aria-roledescription': {enabled: false},
       'aria-treeitem-name': {enabled: true},
       'aria-text': {enabled: true},
+      'autocomplete-valid': {enabled: true},
       'audio-caption': {enabled: false},
       'blink': {enabled: false},
       'duplicate-id': {enabled: false},
@@ -69,6 +70,7 @@ async function runA11yChecks() {
       // https://github.com/dequelabs/axe-core/issues/2958
       'nested-interactive': {enabled: false},
       'no-autoplay-audio': {enabled: false},
+      'presentation-role-conflict': {enabled: true},
       'role-img-alt': {enabled: false},
       'scrollable-region-focusable': {enabled: false},
       'select-name': {enabled: true},
@@ -76,7 +78,7 @@ async function runA11yChecks() {
       'skip-link': {enabled: true},
       // https://github.com/GoogleChrome/lighthouse/issues/16163
       'summary-name': {enabled: false},
-      'svg-img-alt': {enabled: false},
+      'svg-img-alt': {enabled: true},
       'tabindex': {enabled: true},
       'table-duplicate-name': {enabled: true},
       'table-fake-caption': {enabled: true},
@@ -176,6 +178,8 @@ function createAxeRuleResultArtifact(result) {
     tags: result.tags,
     nodes,
     error,
+    help: result.help,
+    description: result.description,
   };
 }
 /* c8 ignore stop */

package/core/gather/gatherers/agentic/llms-txt.d.ts

@@ -0,0 +1,10 @@
+export default LlmsTxt;
+declare class LlmsTxt extends BaseGatherer {
+    /**
+     * @param {LH.Gatherer.Context} passContext
+     * @return {Promise<LH.Artifacts['LlmsTxt']>}
+     */
+    getArtifact(passContext: LH.Gatherer.Context): Promise<LH.Artifacts["LlmsTxt"]>;
+}
+import BaseGatherer from '../../base-gatherer.js';
+//# sourceMappingURL=llms-txt.d.ts.map

package/core/gather/gatherers/agentic/llms-txt.js

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+
+import BaseGatherer from '../../base-gatherer.js';
+
+class LlmsTxt extends BaseGatherer {
+  /** @type {LH.Gatherer.GathererMeta} */
+  meta = {
+    supportedModes: ['snapshot', 'navigation'],
+  };
+
+  /**
+   * @param {LH.Gatherer.Context} passContext
+   * @return {Promise<LH.Artifacts['LlmsTxt']>}
+   */
+  async getArtifact(passContext) {
+    const {finalDisplayedUrl} = passContext.baseArtifacts.URL;
+    const llmUrl = new URL('/llms.txt', finalDisplayedUrl).href;
+    return passContext.driver.fetcher.fetchResource(llmUrl)
+      .catch(err => ({status: null, content: null, errorMessage: err.message}));
+  }
+}
+
+export default LlmsTxt;

package/core/gather/gatherers/inputs.js

@@ -33,6 +33,8 @@ function collectElements() {
       autocomplete: formEl.autocomplete,
       // @ts-expect-error - getNodeDetails put into scope via stringification
       node: getNodeDetails(formEl),
+      webMcpToolname: formEl.getAttribute('toolname'),
+      webMcpTooldescription: formEl.getAttribute('tooldescription'),
     });
   }
 

package/core/gather/gatherers/meta-elements.js

@@ -32,7 +32,7 @@ function collectMetaElements() {
       property: getAttribute('property'),
       httpEquiv: meta.httpEquiv ? meta.httpEquiv.toLowerCase() : undefined,
       charset: getAttribute('charset'),
-      node: functions.getNodeDetails(meta),
+      node: /** @type {LH.Artifacts.NodeDetails} */ (functions.getNodeDetails(meta)),
     };
   });
 }

package/core/gather/gatherers/trace-elements.js

@@ -142,7 +142,7 @@ class TraceElements extends BaseGatherer {
     }, new Set());
 
     // TODO: handle digging into Map in recursiveObjectEnumerate.
-    for (const shift of insightSet.model.CLSCulprits.shifts.values()) {
+    for (const shift of insightSet.model.CLSCulprits?.shifts.values() ?? []) {
       nodeIds.push(...shift.unsizedImages.map(s => s.backendNodeId));
     }
 

package/core/gather/gatherers/webmcp-schema.d.ts

@@ -0,0 +1,25 @@
+export default WebMcpSchemaIssues;
+declare class WebMcpSchemaIssues extends BaseGatherer {
+    /** @type {LH.Artifacts.WebMcpSchemaIssue[]} */
+    _issues: LH.Artifacts.WebMcpSchemaIssue[];
+    _onIssueAdded: (event: Record<string, any>) => void;
+    /**
+     * @param {Record<string, any>} event
+     */
+    onIssueAdded(event: Record<string, any>): void;
+    /**
+     * @param {LH.Gatherer.Context} passContext
+     */
+    startInstrumentation(passContext: LH.Gatherer.Context): Promise<void>;
+    /**
+     * @param {LH.Gatherer.Context} passContext
+     */
+    stopInstrumentation(passContext: LH.Gatherer.Context): Promise<void>;
+    /**
+     * @param {LH.Gatherer.Context} context
+     * @return {Promise<LH.Artifacts.WebMcpSchemaIssue[]>}
+     */
+    getArtifact(context: LH.Gatherer.Context): Promise<LH.Artifacts.WebMcpSchemaIssue[]>;
+}
+import BaseGatherer from '../base-gatherer.js';
+//# sourceMappingURL=webmcp-schema.d.ts.map

package/core/gather/gatherers/webmcp-schema.js

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import BaseGatherer from '../base-gatherer.js';
+import {resolveNodeIdToObjectId} from '../driver/dom.js';
+import {pageFunctions} from '../../lib/page-functions.js';
+import {ExecutionContext} from '../driver/execution-context.js';
+
+class WebMcpSchemaIssues extends BaseGatherer {
+  /** @type {LH.Gatherer.GathererMeta} */
+  meta = {
+    supportedModes: ['navigation', 'snapshot'],
+  };
+
+  constructor() {
+    super();
+    /** @type {LH.Artifacts.WebMcpSchemaIssue[]} */
+    this._issues = [];
+    this._onIssueAdded = this.onIssueAdded.bind(this);
+  }
+
+  /**
+   * @param {Record<string, any>} event
+   */
+  onIssueAdded(event) {
+    const issue = event.issue;
+    if (!issue || issue.code !== 'GenericIssue') return;
+
+    const details = issue.details?.genericIssueDetails;
+    if (!details) return;
+
+    const errorType = details.errorType;
+    if (errorType && (
+      errorType === 'FormModelContextMissingToolName' ||
+      errorType === 'FormModelContextMissingToolDescription' ||
+      errorType === 'FormModelContextRequiredParameterMissingName' ||
+      errorType === 'FormModelContextParameterMissingTitleAndDescription' ||
+      errorType === 'FormModelContextParameterMissingName'
+    )) {
+      this._issues.push(details);
+    }
+  }
+
+  /**
+   * @param {LH.Gatherer.Context} passContext
+   */
+  async startInstrumentation(passContext) {
+    const session = passContext.driver.defaultSession;
+    session.on('Audits.issueAdded', this._onIssueAdded);
+    await session.sendCommand('Audits.enable');
+  }
+
+  /**
+   * @param {LH.Gatherer.Context} passContext
+   */
+  async stopInstrumentation(passContext) {
+    const session = passContext.driver.defaultSession;
+    session.off('Audits.issueAdded', this._onIssueAdded);
+  }
+
+  /**
+   * @param {LH.Gatherer.Context} context
+   * @return {Promise<LH.Artifacts.WebMcpSchemaIssue[]>}
+   */
+  async getArtifact(context) {
+    const session = context.driver.defaultSession;
+
+    const deps = ExecutionContext.serializeDeps([
+      pageFunctions.getNodeDetails,
+    ]);
+
+    const promises = this._issues.map(async (issue) => {
+      const processedIssue = {...issue};
+      if (issue.violatingNodeId) {
+        try {
+          const objectId = await resolveNodeIdToObjectId(session, issue.violatingNodeId);
+          if (objectId) {
+            const response = await session.sendCommand('Runtime.callFunctionOn', {
+              objectId,
+              functionDeclaration: `function () {
+                ${deps}
+                return getNodeDetails(this);
+              }`,
+              returnByValue: true,
+              awaitPromise: true,
+            });
+            if (response && response.result && response.result.value) {
+              processedIssue.nodeDetails = response.result.value;
+            }
+          }
+        } catch (err) {
+          // Ignore error
+        }
+      }
+      return processedIssue;
+    });
+
+    return Promise.all(promises);
+  }
+}
+
+export default WebMcpSchemaIssues;

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

@@ -0,0 +1,58 @@
+export default WebMCP;
+export type WebMCPTool = {
+    name: string;
+    description: string;
+    inputSchema: Record<string, any>;
+    frameId: string;
+    backendNodeId?: number | undefined;
+    stackTrace?: any;
+    nodeDetails?: import("../../index.js").Artifacts.NodeDetails | undefined;
+};
+/**
+ * @typedef {Object} WebMCPTool
+ * @property {string} name
+ * @property {string} description
+ * @property {Record<string, any>} inputSchema
+ * @property {string} frameId
+ * @property {number} [backendNodeId]
+ * @property {any} [stackTrace]
+ * @property {LH.Artifacts.NodeDetails} [nodeDetails]
+ */
+declare class WebMCP extends BaseGatherer {
+    /** @type {WebMCPTool[]} */
+    _tools: WebMCPTool[];
+    _isSupported: boolean;
+    _onToolsAdded: (event: {
+        tools: WebMCPTool[];
+    }) => void;
+    _onToolsRemoved: (event: {
+        tools: WebMCPTool[];
+    }) => void;
+    /**
+     * @param {{tools: WebMCPTool[]}} event
+     */
+    onToolsAdded(event: {
+        tools: WebMCPTool[];
+    }): void;
+    /**
+     * @param {{tools: WebMCPTool[]}} event
+     */
+    onToolsRemoved(event: {
+        tools: WebMCPTool[];
+    }): void;
+    /**
+     * @param {LH.Gatherer.Context} passContext
+     */
+    startInstrumentation(passContext: LH.Gatherer.Context): Promise<void>;
+    /**
+     * @param {LH.Gatherer.Context} passContext
+     */
+    stopInstrumentation(passContext: LH.Gatherer.Context): Promise<void>;
+    /**
+     * @param {LH.Gatherer.Context} context
+     * @return {Promise<LH.Artifacts['WebMCP']>}
+     */
+    getArtifact(context: LH.Gatherer.Context): Promise<LH.Artifacts["WebMCP"]>;
+}
+import BaseGatherer from '../base-gatherer.js';
+//# sourceMappingURL=webmcp.d.ts.map

package/core/gather/gatherers/webmcp.js

@@ -0,0 +1,159 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Capture WebMCP data
+ */
+
+import BaseGatherer from '../base-gatherer.js';
+import {resolveNodeIdToObjectId} from '../driver/dom.js';
+import {pageFunctions} from '../../lib/page-functions.js';
+import {ExecutionContext} from '../driver/execution-context.js';
+
+/**
+ * @typedef {Object} WebMCPTool
+ * @property {string} name
+ * @property {string} description
+ * @property {Record<string, any>} inputSchema
+ * @property {string} frameId
+ * @property {number} [backendNodeId]
+ * @property {any} [stackTrace]
+ * @property {LH.Artifacts.NodeDetails} [nodeDetails]
+ */
+class WebMCP extends BaseGatherer {
+  /** @type {LH.Gatherer.GathererMeta} */
+  meta = {
+    supportedModes: ['navigation', 'snapshot'],
+  };
+
+  constructor() {
+    super();
+    /** @type {WebMCPTool[]} */
+    this._tools = [];
+    this._isSupported = true;
+    this._onToolsAdded = this.onToolsAdded.bind(this);
+    this._onToolsRemoved = this.onToolsRemoved.bind(this);
+  }
+
+  /**
+   * @param {{tools: WebMCPTool[]}} event
+   */
+  // TODO: Handle WebMCP tools per frame.
+  onToolsAdded(event) {
+    // Note that as of M148, there is a bug in WebMCP CDP.
+    // While WebMCP is enabled, any newly registered tool will
+    // have an empty schema.
+    if (event.tools) {
+      this._tools.push(...event.tools);
+    }
+  }
+
+  /**
+   * @param {{tools: WebMCPTool[]}} event
+   */
+  onToolsRemoved(event) {
+    if (event.tools) {
+      const removedNames = new Set(event.tools.map(t => t.name));
+      this._tools = this._tools.filter(t => !removedNames.has(t.name));
+    }
+  }
+
+  /**
+   * @param {LH.Gatherer.Context} passContext
+   */
+  async startInstrumentation(passContext) {
+    const session = passContext.driver.defaultSession;
+
+    // @ts-expect-error - WebMCP domain might not be in types yet.
+    session.on('WebMCP.toolsAdded', this._onToolsAdded);
+    // @ts-expect-error
+    session.on('WebMCP.toolsRemoved', this._onToolsRemoved);
+
+    try {
+      await session.sendCommand('WebMCP.enable');
+    } catch (err) {
+      if (err.message.includes('\'WebMCP.enable\' wasn\'t found')) {
+        this._isSupported = false;
+        return;
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * @param {LH.Gatherer.Context} passContext
+   */
+  async stopInstrumentation(passContext) {
+    const session = passContext.driver.defaultSession;
+    // @ts-expect-error
+    session.off('WebMCP.toolsAdded', this._onToolsAdded);
+    // @ts-expect-error
+    session.off('WebMCP.toolsRemoved', this._onToolsRemoved);
+    try {
+      await session.sendCommand('WebMCP.disable');
+    } catch (err) {
+      // Ignore errors
+    }
+  }
+
+  /**
+   * @param {LH.Gatherer.Context} context
+   * @return {Promise<LH.Artifacts['WebMCP']>}
+   */
+  async getArtifact(context) {
+    const isSupported = await context.driver.executionContext.evaluate(
+      // @ts-expect-error - modelContext is not in types
+      () => typeof navigator.modelContext !== 'undefined',
+      {args: [], useIsolation: true}
+    );
+    if (!isSupported || !this._isSupported) {
+      return {isSupported: false, tools: []};
+    }
+
+    const session = context.driver.defaultSession;
+
+    // Remove duplicates based on name, keeping the latest occurrence.
+    const toolMap = new Map();
+    for (const tool of this._tools) {
+      toolMap.set(tool.name, tool);
+    }
+
+    const resolvedTools = [];
+    for (const tool of toolMap.values()) {
+      if (tool.backendNodeId) {
+        try {
+          const objectId = await resolveNodeIdToObjectId(session, tool.backendNodeId);
+          if (objectId) {
+            const deps = ExecutionContext.serializeDeps([
+              pageFunctions.getNodeDetails,
+            ]);
+            const response = await session.sendCommand('Runtime.callFunctionOn', {
+              objectId,
+              functionDeclaration: `function () {
+                ${deps}
+                return getNodeDetails(this);
+              }`,
+              returnByValue: true,
+              awaitPromise: true,
+            });
+            if (response && response.result && response.result.value) {
+              tool.nodeDetails = response.result.value;
+            }
+          }
+        } catch (err) {
+          // Ignore error
+        }
+      }
+      resolvedTools.push(tool);
+    }
+    return {
+      isSupported: true,
+      tools: resolvedTools,
+    };
+  }
+}
+
+export default WebMCP;

package/core/lib/baseline/web-features-metadata.json

@@ -1,3 +1,3 @@
 {
-  "date": "2026-03-18"
+  "date": "2026-05-01"
 }

package/core/lib/cdt/generated/SourceMap.js

@@ -381,7 +381,7 @@ class SourceMap {
         let nameIndex = 0;
         const names = map.names ?? [];
         const tokenIter = new TokenIterator(map.mappings);
-        let sourceURL = this.#sourceInfos[sourceIndex].sourceURL;
+        let sourceURL = this.#sourceInfos[sourceIndex]?.sourceURL;
         while (true) {
             if (tokenIter.peek() === ',') {
                 tokenIter.next();
@@ -404,7 +404,7 @@ class SourceMap {
             const sourceIndexDelta = tokenIter.nextVLQ();
             if (sourceIndexDelta) {
                 sourceIndex += sourceIndexDelta;
-                sourceURL = this.#sourceInfos[sourceIndex].sourceURL;
+                sourceURL = this.#sourceInfos[sourceIndex]?.sourceURL;
             }
             sourceLineNumber += tokenIter.nextVLQ();
             sourceColumnNumber += tokenIter.nextVLQ();