lighthouse 13.1.0 → 13.3.0

package/core/audits/webmcp-form-coverage.d.ts

@@ -0,0 +1,16 @@
+export default WebMcpFormCoverage;
+declare class WebMcpFormCoverage 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 displayValue: string;
+    let columnForm: string;
+}
+import { Audit } from './audit.js';
+//# sourceMappingURL=webmcp-form-coverage.d.ts.map

package/core/audits/webmcp-form-coverage.js

@@ -0,0 +1,90 @@
+/**
+ * @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 lists forms found in the page for WebMCP coverage. "WebMCP" stands for "Web Model Context Protocol" and should not be translated. */
+  title: 'WebMCP form coverage',
+  /** Description of a Lighthouse audit that lists forms found in the page and indicates whether they have WebMCP declarative tool annotations. 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: 'Consider adding [WebMCP](http://goo.gle/webmcp-docs) annotations to the forms listed below. This helps AI ' +
+  'agents identify and interact with these forms more reliably.',
+  /** [ICU Syntax] Label for the audit identifying the number of forms missing annotations. "WebMCP" stands for "Web Model Context Protocol" and should not be translated. */
+  displayValue: `{itemCount, plural,
+    =1 {1 form missing annotations}
+    other {# forms missing annotations}
+    }`,
+  /** Label for a column in a data table; entries will be the form element found on the page. */
+  columnForm: 'Form',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class WebMcpFormCoverage extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'webmcp-form-coverage',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Inputs', 'WebMCP'],
+      supportedModes: ['navigation', 'snapshot'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {LH.Audit.Product}
+   */
+  static audit(artifacts) {
+    const forms = artifacts.Inputs.forms;
+    if (forms.length === 0 || !artifacts.WebMCP.isSupported) {
+      return {
+        notApplicable: true,
+        score: 1,
+      };
+    }
+    const withoutTools = [];
+
+    for (const form of forms) {
+      const hasToolName = !!form.webMcpToolname;
+      const hasToolDescription = !!form.webMcpTooldescription;
+
+      if (!hasToolName && !hasToolDescription) {
+        withoutTools.push({
+          node: Audit.makeNodeItem(form.node),
+        });
+      }
+    }
+
+    if (withoutTools.length === 0) {
+      return {
+        notApplicable: true,
+        score: 1,
+      };
+    }
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'node', valueType: 'node', label: str_(UIStrings.columnForm)},
+    ];
+
+    const details = Audit.makeTableDetails(headings, withoutTools);
+
+    return {
+      score: 1,
+      displayValue: str_(UIStrings.displayValue, {itemCount: withoutTools.length}),
+      details,
+    };
+  }
+}
+
+export default WebMcpFormCoverage;
+export {UIStrings};

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](http://goo.gle/webmcp-docs) 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](http://goo.gle/webmcp-docs) 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](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);
+
+/** @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};