lighthouse 13.2.0 → 13.4.0

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

@@ -20,7 +20,6 @@ import Trace from './trace.js';
 import {ProcessedTrace} from '../../computed/processed-trace.js';
 import {Responsiveness} from '../../computed/metrics/responsiveness.js';
 import {CumulativeLayoutShift} from '../../computed/metrics/cumulative-layout-shift.js';
-import {ExecutionContext} from '../driver/execution-context.js';
 import {TraceEngineResult} from '../../computed/trace-engine-result.js';
 import SourceMaps from './source-maps.js';
 
@@ -29,14 +28,14 @@ import SourceMaps from './source-maps.js';
 const MAX_LAYOUT_SHIFTS = 15;
 
 /**
- * @this {HTMLElement}
+ * @param {Element | ShadowRoot | Text} node
  */
 /* c8 ignore start */
-function getNodeDetailsData() {
-  /** @type {Element|null} */
-  let elem = this.nodeType === document.ELEMENT_NODE ? this : this.parentElement;
-  if (!elem && this instanceof ShadowRoot) {
-    elem = this.host;
+function getNodeDetailsData(node) {
+  /** @type {Element | ShadowRoot | Text | null} */
+  let elem = node.nodeType === document.ELEMENT_NODE ? node : node.parentElement;
+  if (!elem && node instanceof ShadowRoot) {
+    elem = node.host;
   }
 
   let traceElement;
@@ -292,26 +291,22 @@ class TraceElements extends BaseGatherer {
 
   /**
    * @param {LH.Gatherer.ProtocolSession} session
+   * @param {LH.Gatherer.Driver['executionContext']} executionContext
    * @param {number} backendNodeId
    */
-  async getNodeDetails(session, backendNodeId) {
+  async getNodeDetails(session, executionContext, backendNodeId) {
     try {
       const objectId = await resolveNodeIdToObjectId(session, backendNodeId);
       if (!objectId) return null;
 
-      const deps = ExecutionContext.serializeDeps([
-        pageFunctions.getNodeDetails,
+      return await executionContext.evaluateOnObject(
         getNodeDetailsData,
-      ]);
-      return await session.sendCommand('Runtime.callFunctionOn', {
-        objectId,
-        functionDeclaration: `function () {
-          ${deps}
-          return getNodeDetailsData.call(this);
-        }`,
-        returnByValue: true,
-        awaitPromise: true,
-      });
+        {
+          objectId,
+          args: [],
+          deps: [pageFunctions.getNodeDetails],
+        }
+      );
     } catch (err) {
       Sentry.captureException(err, {
         tags: {gatherer: 'TraceElements'},
@@ -346,29 +341,30 @@ class TraceElements extends BaseGatherer {
       trace, traceEngineResult, context);
     const animatedElementData = await this.getAnimatedElements(mainThreadEvents);
 
-    /** @type {Map<string, TraceElementData[]>} */
+    /** @type {Map<LH.Artifacts.TraceElement['traceEventType'], TraceElementData[]>} */
     const backendNodeDataMap = new Map([
       ['trace-engine', traceEngineData],
       ['layout-shift', shiftsData],
       ['animation', animatedElementData],
     ]);
 
-    /** @type {Map<number, LH.Crdp.Runtime.CallFunctionOnResponse | null>} */
-    const callFunctionOnCache = new Map();
+    /** @type {Map<number, {node: LH.Artifacts.NodeDetails} | null>} */
+    const evaluateOnObjectCache = new Map();
     /** @type {LH.Artifacts.TraceElement[]} */
     const traceElements = [];
     for (const [traceEventType, backendNodeData] of backendNodeDataMap) {
       for (let i = 0; i < backendNodeData.length; i++) {
         const backendNodeId = backendNodeData[i].nodeId;
-        let response = callFunctionOnCache.get(backendNodeId);
+        let response = evaluateOnObjectCache.get(backendNodeId);
         if (response === undefined) {
-          response = await this.getNodeDetails(session, backendNodeId);
-          callFunctionOnCache.set(backendNodeId, response);
+          response = await this.getNodeDetails(
+            session, context.driver.executionContext, backendNodeId) || null;
+          evaluateOnObjectCache.set(backendNodeId, response);
         }
 
-        if (response?.result?.value) {
+        if (response?.node) {
           traceElements.push({
-            ...response.result.value,
+            ...response,
             traceEventType,
             animations: backendNodeData[i].animations,
             nodeId: backendNodeId,

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

@@ -7,7 +7,6 @@
 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} */
@@ -68,27 +67,21 @@ class WebMcpSchemaIssues extends BaseGatherer {
   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;
+            const nodeDetails = await context.driver.executionContext.evaluateOnObject(
+              pageFunctions.getNodeDetails,
+              {
+                objectId,
+                args: [],
+              }
+            );
+            if (nodeDetails) {
+              processedIssue.nodeDetails = nodeDetails;
             }
           }
         } catch (err) {

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

@@ -48,6 +48,11 @@ declare class WebMCP extends BaseGatherer {
      * @param {LH.Gatherer.Context} passContext
      */
     stopInstrumentation(passContext: LH.Gatherer.Context): Promise<void>;
+    /**
+     * @param {LH.Gatherer.Context} context
+     * @param {WebMCPTool} tool
+     */
+    _tryResolveToolNodeDetails(context: LH.Gatherer.Context, tool: WebMCPTool): Promise<void>;
     /**
      * @param {LH.Gatherer.Context} context
      * @return {Promise<LH.Artifacts['WebMCP']>}

package/core/gather/gatherers/webmcp.js

@@ -11,7 +11,6 @@
 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
@@ -99,6 +98,37 @@ class WebMCP extends BaseGatherer {
     }
   }
 
+  /**
+   * @param {LH.Gatherer.Context} context
+   * @param {WebMCPTool} tool
+   */
+  async _tryResolveToolNodeDetails(context, tool) {
+    if (!tool.backendNodeId) {
+      return;
+    }
+
+    const session = context.driver.defaultSession;
+
+    try {
+      const objectId = await resolveNodeIdToObjectId(session, tool.backendNodeId);
+      if (!objectId) {
+        return;
+      }
+
+      const nodeDetails = await context.driver.executionContext.evaluateOnObject(
+        pageFunctions.getNodeDetails, {
+          objectId,
+          args: [],
+        }
+      );
+      if (nodeDetails) {
+        tool.nodeDetails = nodeDetails;
+      }
+    } catch (err) {
+      // Ignore error
+    }
+  }
+
   /**
    * @param {LH.Gatherer.Context} context
    * @return {Promise<LH.Artifacts['WebMCP']>}
@@ -113,9 +143,8 @@ class WebMCP extends BaseGatherer {
       return {isSupported: false, tools: []};
     }
 
-    const session = context.driver.defaultSession;
-
     // Remove duplicates based on name, keeping the latest occurrence.
+    /** @type {Map<string, WebMCPTool>} */
     const toolMap = new Map();
     for (const tool of this._tools) {
       toolMap.set(tool.name, tool);
@@ -123,32 +152,10 @@ class WebMCP extends BaseGatherer {
 
     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
-        }
-      }
+      await this._tryResolveToolNodeDetails(context, tool);
       resolvedTools.push(tool);
     }
+
     return {
       isSupported: true,
       tools: resolvedTools,

package/core/index.d.ts

@@ -4,7 +4,6 @@ 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,7 +121,6 @@ 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,