lighthouse 13.0.3 → 13.2.0

package/core/gather/gatherers/trace.js

@@ -61,6 +61,9 @@ class Trace extends BaseGatherer {
       'disabled-by-default-devtools.v8-source-rundown-sources',
       'disabled-by-default-devtools.v8-source-rundown',
 
+      // Required for Baseline Audit to detect feature usage.
+      'blink.webdx_feature_usage',
+
       // Not used by Lighthouse (yet) but included for users that want JS samples when looking at
       // a trace collected by Lighthouse (e.g. "View Trace" workflow in DevTools)
       // TODO: Re-enable after investigating b/325659693

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/index.d.ts

@@ -4,6 +4,7 @@ export { default as Gatherer } from "./gather/base-gatherer.js";
 export { NetworkRecords } from "./computed/network-records.js";
 export { default as defaultConfig } from "./config/default-config.js";
 export { default as desktopConfig } from "./config/desktop-config.js";
+export { default as agenticBrowsingConfig } from "./config/agentic-browsing-config.js";
 export * from "../types/lh.js";
 /**
  * Run Lighthouse.

package/core/index.js

@@ -121,6 +121,7 @@ export {default as Gatherer} from './gather/base-gatherer.js';
 export {NetworkRecords} from './computed/network-records.js';
 export {default as defaultConfig} from './config/default-config.js';
 export {default as desktopConfig} from './config/desktop-config.js';
+export {default as agenticBrowsingConfig} from './config/agentic-browsing-config.js';
 export * from '../types/lh.js';
 export {
   startFlow,

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

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

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();