lighthouse 13.1.0 → 13.2.0

package/core/audits/webmcp-registered-tools.d.ts

@@ -0,0 +1,21 @@
+export default WebMCPRegisteredTools;
+declare class WebMCPRegisteredTools extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Audit.Product}
+     */
+    static audit(artifacts: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    let title: string;
+    let description: string;
+    let columnTool: string;
+    let columnDescription: string;
+    let columnImperativeLocation: string;
+    let columnDeclarativeElement: string;
+    let columnInputSchema: string;
+    let titleImperativeTools: string;
+    let titleDeclarativeTools: string;
+}
+import { Audit } from './audit.js';
+//# sourceMappingURL=webmcp-registered-tools.d.ts.map

package/core/audits/webmcp-registered-tools.js

@@ -0,0 +1,149 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Audit that lists registered WebMCP tools.
+ */
+
+import {Audit} from './audit.js';
+import * as i18n from '../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that lists registered WebMCP tools. "WebMCP" stands for "Web Model Context Protocol" and should not be translated. */
+  title: 'WebMCP tools registered',
+  /** Description of a Lighthouse audit that lists registered WebMCP tools. This is displayed after a user expands the section to see more. No character length limits. "WebMCP" stands for "Web Model Context Protocol", neither should be translated. */
+  description: 'Lists the WebMCP tools registered at the time of analysis. ',
+  /** Label for a column in a data table; entries will be the name of a WebMCP tool. */
+  columnTool: 'Tool name',
+  /** Label for a column in a data table; entries will be the description of a WebMCP tool. */
+  columnDescription: 'Description',
+  /** Label for a column in a data table; entries will be the source location where an imperative WebMCP tool was registered. */
+  columnImperativeLocation: 'Source Location',
+  /** Label for a column in a data table; entries will be the DOM element associated with a declarative WebMCP tool. */
+  columnDeclarativeElement: 'Element',
+  /** Label for a column in a data table; entries will be the input schema of a WebMCP tool. */
+  columnInputSchema: 'Input schema',
+  /** Title for the table listing imperative WebMCP tools. */
+  titleImperativeTools: 'Imperative Tools',
+  /** Title for the table listing declarative WebMCP tools. */
+  titleDeclarativeTools: 'Declarative Tools',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class WebMCPRegisteredTools extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'webmcp-registered-tools',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['WebMCP'],
+      supportedModes: ['navigation', 'snapshot'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {LH.Audit.Product}
+   */
+  static audit(artifacts) {
+    if (!artifacts.WebMCP.isSupported) {
+      return {
+        notApplicable: true,
+        score: 1,
+      };
+    }
+
+    const tools = artifacts.WebMCP.tools || [];
+
+    const imperativeResults = [];
+    const declarativeResults = [];
+
+    for (const tool of tools) {
+      const isDeclarative = typeof tool.backendNodeId === 'number';
+
+      let source;
+      let element;
+
+      if (isDeclarative && tool.nodeDetails) {
+        element = Audit.makeNodeItem(tool.nodeDetails);
+      } else if (isDeclarative) {
+        element = `Node ID: ${tool.backendNodeId}`;
+      } else if (tool.stackTrace) {
+        const callFrame = tool.stackTrace.callFrames?.[0];
+        if (callFrame) {
+          source =
+            Audit.makeSourceLocation(
+              callFrame.url, callFrame.lineNumber, callFrame.columnNumber || 0
+            );
+        }
+      }
+
+      const item = {
+        tool: tool.name,
+        description: tool.description,
+        inputSchema: JSON.stringify(tool.inputSchema, null, 2),
+      };
+
+      if (isDeclarative) {
+        declarativeResults.push({
+          ...item,
+          element,
+        });
+      } else {
+        imperativeResults.push({
+          ...item,
+          source,
+        });
+      }
+    }
+
+    const list = [];
+
+    if (imperativeResults.length > 0) {
+      /** @type {LH.Audit.Details.Table['headings']} */
+      const headings = [
+        {key: 'tool', valueType: 'text', label: str_(UIStrings.columnTool)},
+        {key: 'description', valueType: 'text', label: str_(UIStrings.columnDescription)},
+        {key: 'source', valueType: 'source-location',
+          label: str_(UIStrings.columnImperativeLocation)},
+        {key: 'inputSchema', valueType: 'code', label: str_(UIStrings.columnInputSchema)},
+      ];
+      const table = Audit.makeTableDetails(headings, imperativeResults);
+      list.push(Audit.makeListDetailSectionItem(table, str_(UIStrings.titleImperativeTools)));
+    }
+
+    if (declarativeResults.length > 0) {
+      /** @type {LH.Audit.Details.Table['headings']} */
+      const headings = [
+        {key: 'tool', valueType: 'text', label: str_(UIStrings.columnTool)},
+        {key: 'description', valueType: 'text', label: str_(UIStrings.columnDescription)},
+        {key: 'element', valueType: 'node', label: str_(UIStrings.columnDeclarativeElement)},
+        {key: 'inputSchema', valueType: 'code', label: str_(UIStrings.columnInputSchema)},
+      ];
+      const table = Audit.makeTableDetails(headings, declarativeResults);
+      list.push(Audit.makeListDetailSectionItem(table, str_(UIStrings.titleDeclarativeTools)));
+    }
+
+    if (list.length === 0) {
+      return {
+        score: 1,
+      };
+    }
+
+    return {
+      score: 1,
+      details: Audit.makeListDetails(list),
+    };
+  }
+}
+
+export default WebMCPRegisteredTools;
+export {UIStrings};

package/core/audits/webmcp-schema-validity.d.ts

@@ -0,0 +1,22 @@
+export default WebMcpSchemaValidity;
+declare class WebMcpSchemaValidity extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    let title: string;
+    let failureTitle: string;
+    let description: string;
+    let columnElement: string;
+    let columnIssue: string;
+    let missingToolName: string;
+    let missingToolDescription: string;
+    let missingRequiredParamName: string;
+    let missingOptionalParamName: string;
+    let missingParamDescription: string;
+}
+import { Audit } from './audit.js';
+//# sourceMappingURL=webmcp-schema-validity.d.ts.map

package/core/audits/webmcp-schema-validity.js

@@ -0,0 +1,141 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {Audit} from './audit.js';
+import * as i18n from '../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that evaluates WebMCP schema validity. This descriptive title is shown to users when there are no schema validity issues. "WebMCP" stands for "Web Model Context Protocol" and should not be translated. */
+  title: 'WebMCP schemas are valid',
+  /** Title of a Lighthouse audit that provides detail on WebMCP schema validity. This descriptive title is shown to users when there are schema validity issues. "WebMCP" stands for "Web Model Context Protocol" and should not be translated. */
+  failureTitle: 'WebMCP schemas are invalid',
+  /** Description of a Lighthouse audit that tells the user why they should ensure WebMCP schemas are valid. This is displayed after a user expands the section to see more. No character length limits. "WebMCP" stands for "Web Model Context Protocol" and should not be translated. */
+  description: 'Valid WebMCP schemas are required for AI agents to ' +
+  ' understand and interact with tools correctly. ' +
+      'Please fix any errors or warnings reported by the browser.',
+  /** Header of the table column which displays the element. */
+  columnElement: 'Element',
+  /** Header of the table column which displays the issue. */
+  columnIssue: 'Issue',
+  /** Descriptive reason for why a form fails WebMCP validation due to missing `toolname` attribute. */
+  missingToolName: 'Form level `toolname` attribute is missing. Add it to define the tool name.',
+  /** Descriptive reason for why a form fails WebMCP validation due to missing `tooldescription` attribute. */
+  missingToolDescription: 'Form level `tooldescription` attribute is missing. ' +
+  'Add it to describe the tool for AI agents.',
+  /** Descriptive reason for why a form field fails WebMCP validation due to missing `name` attribute for a required field. */
+  missingRequiredParamName: 'Missing `name` attribute for a required field. ' +
+  'Add it to define the parameter name.',
+  /** Descriptive reason for why a form field fails WebMCP validation due to missing `name` attribute for an optional field. */
+  missingOptionalParamName: 'Missing `name` attribute for an optional field. ' +
+  'Add it to define the parameter name.',
+  /** Descriptive reason for why a form field fails WebMCP validation due to missing description. */
+  missingParamDescription: 'Add a description to make this form more accessible for AI agents.',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class WebMcpSchemaValidity extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'webmcp-schema-validity',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['WebMCP', 'WebMcpSchemaIssues'],
+      supportedModes: ['navigation', 'snapshot'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts) {
+    if (!artifacts.WebMCP.isSupported) {
+      return {
+        notApplicable: true,
+        score: 1,
+      };
+    }
+
+    /** @enum {number} */
+    const Severity = {
+      ERROR: 1,
+      WARNING: 2,
+    };
+
+    /** @type {Record<string, {severity: Severity, description: LH.IcuMessage}>} */
+    const issueConfigs = {
+      'FormModelContextMissingToolName': {
+        severity: Severity.ERROR,
+        description: str_(UIStrings.missingToolName),
+      },
+      'FormModelContextMissingToolDescription': {
+        severity: Severity.ERROR,
+        description: str_(UIStrings.missingToolDescription),
+      },
+      'FormModelContextRequiredParameterMissingName': {
+        severity: Severity.ERROR,
+        description: str_(UIStrings.missingRequiredParamName),
+      },
+      'FormModelContextParameterMissingTitleAndDescription': {
+        severity: Severity.WARNING,
+        description: str_(UIStrings.missingParamDescription),
+      },
+      'FormModelContextParameterMissingName': {
+        severity: Severity.WARNING,
+        description: str_(UIStrings.missingOptionalParamName),
+      },
+    };
+
+    const rawIssues = artifacts.WebMcpSchemaIssues;
+
+    const uniqueIssues = [
+      ...new Map(
+      rawIssues.map(issue => [`${issue.violatingNodeId}_${issue.errorType}`, issue])
+      ).values(),
+    ];
+    const sortedUniqueIssues = uniqueIssues.sort((a, b) => {
+      return (issueConfigs[a.errorType]?.severity || Severity.ERROR) -
+      (issueConfigs[b.errorType]?.severity || Severity.ERROR);
+    });
+    const items = sortedUniqueIssues.map(issue => {
+      return {
+        element: issue.nodeDetails ? Audit.makeNodeItem(issue.nodeDetails) : undefined,
+        issue: issueConfigs[issue.errorType]?.description || '',
+      };
+    });
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'element', valueType: 'node', label: str_(UIStrings.columnElement)},
+      {key: 'issue', valueType: 'text', label: str_(UIStrings.columnIssue)},
+    ];
+
+    const details = Audit.makeTableDetails(headings, items);
+
+    const hasErrors =
+    sortedUniqueIssues.some(issue => issueConfigs[issue.errorType]?.severity === Severity.ERROR);
+
+    if ((artifacts.WebMCP.tools?.length || 0) === 0 && rawIssues.length === 0) {
+      return {
+        notApplicable: true,
+        score: 1,
+      };
+    }
+
+    return {
+      score: hasErrors ? 0 : (items.length > 0 ? 0.5 : 1),
+      details: items.length > 0 ? details : undefined,
+    };
+  }
+}
+
+export default WebMcpSchemaValidity;
+export {UIStrings};

package/core/computed/document-urls.js

@@ -42,7 +42,6 @@ class DocumentUrls {
     if (!requestedUrl || !mainDocumentUrl) throw new Error('No main frame navigations found');
 
     const initialRequest = Lantern.Core.NetworkAnalyzer.findResourceForUrl(
-      // @ts-expect-error - trace engine types for InitiatorType are outdated
       networkRecords,
       requestedUrl
     );

package/core/computed/main-resource.js

@@ -29,7 +29,6 @@ class MainResource {
     // would have evicted the first request by the time `MainDocumentRequest` (a consumer
     // of this computed artifact) attempts to fetch the contents, resulting in a protocol error.
     const mainResource = Lantern.Core.NetworkAnalyzer.findLastDocumentForUrl(
-      // @ts-expect-error - trace engine types for InitiatorType are outdated
       records,
       mainDocumentUrl
     );
@@ -37,7 +36,6 @@ class MainResource {
       throw new Error('Unable to identify the main resource');
     }
 
-    // @ts-expect-error - Return type is typed as Lantern request by trace engine, but it is a raw record at runtime since we passed raw records.
     return mainResource;
   }
 }

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

@@ -39,14 +39,14 @@ async function getComputationDataParamsFromTrace(data, context) {
   const graph = await PageDependencyGraph.request({...data, fromTrace: true}, context);
   const traceEngineResult = await TraceEngineResult.request(data, context);
   const frameId = traceEngineResult.data.Meta.mainFrameId;
-  const navigationId =
-    traceEngineResult.data.Meta.mainFrameNavigations[0].args.data?.navigationId;
-  if (!navigationId) {
+  const navigation =
+    traceEngineResult.data.Meta.mainFrameNavigations[0];
+  if (!navigation) {
     throw new Error(`Lantern metrics could not be calculated due to missing navigation id`);
   }
 
   const processedNavigation = Lantern.TraceEngineComputationData.createProcessedNavigation(
-    traceEngineResult.data, frameId, navigationId);
+    traceEngineResult.data, frameId, navigation);
   const simulator = data.simulator || (await LoadSimulator.request(data, context));
 
   return {simulator, graph, processedNavigation};

package/core/computed/metrics/lcp-breakdown.js

@@ -62,7 +62,7 @@ class LCPBreakdown {
       throw new LighthouseError(LighthouseError.errors.NO_LCP, {}, {cause: lcpBreakdown});
     }
 
-    if (!lcpBreakdown.subparts) {
+    if (!lcpBreakdown || !lcpBreakdown.subparts) {
       throw new LighthouseError(LighthouseError.errors.NO_LCP);
     }
 

package/core/computed/metrics/time-to-first-byte.js

@@ -53,7 +53,7 @@ class TimeToFirstByte extends NavigationMetric {
     const lcpBreakdown = navInsights.model.LCPBreakdown;
 
     // Defer to LCP breakdown, but if there's no LCP fallback to manual calculation.
-    if (!(lcpBreakdown instanceof Error) && lcpBreakdown.subparts) {
+    if (lcpBreakdown && !(lcpBreakdown instanceof Error) && lcpBreakdown.subparts) {
       return {
         timing: lcpBreakdown.subparts.ttfb.range / 1000,
         timestamp: lcpBreakdown.subparts.ttfb.max,

package/core/computed/navigation-insights.js

@@ -26,7 +26,8 @@ class NavigationInsights {
     const navigationId = processedTrace.timeOriginEvt.args.data?.navigationId;
     if (!navigationId) throw new Error('No navigationId found');
 
-    const navInsights = traceEngineResult.insights.get(navigationId);
+    const navInsights = [...traceEngineResult.insights.values()]
+        .find(insightSet => insightSet.navigation?.args.data?.navigationId === navigationId);
     if (!navInsights) throw new Error('No navigations insights found');
 
     return navInsights;

package/core/computed/network-analysis.js

@@ -19,7 +19,6 @@ class NetworkAnalysis {
   static async compute_(devtoolsLog, context) {
     const records = await NetworkRecords.request(devtoolsLog, context);
     const analysis = Lantern.Core.NetworkAnalyzer.analyze(
-      // @ts-expect-error - trace engine types for InitiatorType are outdated
       records
     );
     if (!analysis) {

package/core/config/agentic-browsing-config.d.ts

@@ -0,0 +1,12 @@
+export default config;
+/** @type {LH.Config} */
+declare const config: LH.Config;
+export namespace UIStrings {
+    let agenticBrowsingCategoryTitle: string;
+    let agenticBrowsingCategoryDescription: string;
+    let webmcpGroupTitle: string;
+    let webmcpGroupDescription: string;
+    let agentAccessibilityGroupTitle: string;
+    let agentAccessibilityGroupDescription: string;
+}
+//# sourceMappingURL=agentic-browsing-config.d.ts.map

package/core/config/agentic-browsing-config.js

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as i18n from '../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** 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 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);
+
+/** @type {LH.Config} */
+const config = {
+  extends: 'lighthouse:default',
+  audits: [
+    'agentic/agent-accessibility-tree',
+    'webmcp-registered-tools',
+    'webmcp-form-coverage',
+    'webmcp-schema-validity',
+    'agentic/llms-txt',
+  ],
+  artifacts: [
+    {id: 'WebMCP', gatherer: 'webmcp'},
+    {id: 'WebMcpSchemaIssues', gatherer: 'webmcp-schema'},
+    {id: 'LlmsTxt', gatherer: 'agentic/llms-txt'},
+  ],
+  groups: {
+    'webmcp': {
+      title: str_(UIStrings.webmcpGroupTitle),
+      description: str_(UIStrings.webmcpGroupDescription),
+    },
+    'agent-accessibility': {
+      title: str_(UIStrings.agentAccessibilityGroupTitle),
+      description: str_(UIStrings.agentAccessibilityGroupDescription),
+    },
+  },
+  categories: {
+    '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'},
+      ],
+    },
+  },
+};
+
+export default config;
+export {UIStrings};

package/core/config/default-config.js

@@ -254,6 +254,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',
@@ -515,6 +518,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},

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