lighthouse 13.1.0 → 13.2.0

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

package/core/lib/navigation-error.js

@@ -131,7 +131,6 @@ function getNonHtmlError(finalRecord) {
 function getPageLoadError(navigationError, context) {
   const {url, networkRecords} = context;
   const mainRecordLantern = Lantern.Core.NetworkAnalyzer.findResourceForUrl(
-    // @ts-expect-error - trace engine types for InitiatorType are outdated
     networkRecords,
     url
   );
@@ -144,7 +143,6 @@ function getPageLoadError(navigationError, context) {
       record.resourceType === NetworkRequest.TYPES.Document
     );
     if (documentRequests.length) {
-      // @ts-expect-error - mainRecord is inferred as a Lantern request from findResourceForUrl, but we assign a raw record here.
       mainRecord = documentRequests.reduce((min, r) => {
         return r.networkRequestTime < min.networkRequestTime ? r : min;
       });
@@ -164,12 +162,8 @@ function getPageLoadError(navigationError, context) {
     context.warnings.push(str_(UIStrings.warningXhtml));
   }
 
-  // @ts-expect-error - mainRecord may be typed as a Lantern request, but functions expect a raw record.
   const networkError = getNetworkError(mainRecord, context);
-  // @ts-expect-error - mainRecord may be typed as a Lantern request, but functions expect a raw record.
   const interstitialError = getInterstitialError(mainRecord, networkRecords);
-  // @ts-expect-error - finalRecord may be a Lantern request, which is compatible enough
-  // for getNonHtmlError.
   const nonHtmlError = getNonHtmlError(finalRecord);
 
   // We want to special-case the interstitial beyond FAILED_DOCUMENT_REQUEST. See https://github.com/GoogleChrome/lighthouse/pull/8865#issuecomment-497507618

package/core/lib/network-request.js

@@ -592,7 +592,6 @@ class NetworkRequest {
 
     record.fromWorker = record.sessionTargetType === 'worker';
 
-    // @ts-expect-error - trace engine types for InitiatorType are outdated
     return {
       rawRequest: record,
       ...record,

package/core/lib/page-functions.d.ts

@@ -88,10 +88,10 @@ declare namespace getOuterHTMLSnippet {
  */
 declare function computeBenchmarkIndex(): number;
 /**
- * @param {Element|ShadowRoot} element
- * @return {LH.Artifacts.NodeDetails}
+ * @param {Node|ShadowRoot} node
+ * @return {LH.Artifacts.NodeDetails | null}
  */
-declare function getNodeDetails(element: Element | ShadowRoot): LH.Artifacts.NodeDetails;
+declare function getNodeDetails(node: Node | ShadowRoot): LH.Artifacts.NodeDetails | null;
 declare namespace getNodeDetails {
     function toString(): string;
 }

package/core/lib/page-functions.js

@@ -450,16 +450,23 @@ function wrapRequestIdleCallback(cpuSlowdownMultiplier) {
 }
 
 /**
- * @param {Element|ShadowRoot} element
- * @return {LH.Artifacts.NodeDetails}
+ * @param {Node|ShadowRoot} node
+ * @return {LH.Artifacts.NodeDetails | null}
  */
-function getNodeDetails(element) {
+function getNodeDetails(node) {
   // This bookkeeping is for the FullPageScreenshot gatherer.
   if (!window.__lighthouseNodesDontTouchOrAllVarianceGoesAway) {
     window.__lighthouseNodesDontTouchOrAllVarianceGoesAway = new Map();
   }
 
-  element = element instanceof ShadowRoot ? element.host : element;
+  let elem = node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
+  if (!elem && node instanceof ShadowRoot) {
+    elem = node.host;
+  }
+
+  if (!elem) return null;
+
+  const element = /** @type {Element} */ (elem);
   const selector = getNodeSelector(element);
 
   // Create an id that will be unique across all execution contexts.

package/core/lib/tracehouse/trace-processor.d.ts

@@ -196,9 +196,10 @@ export class TraceProcessor {
      *
      * @param {LH.TraceEvent[]} events
      * @param {LH.TraceEvent} timeOriginEvent
+     * @param {string|undefined} mainFrameId
      * @return {{lcp: LCPEvent | undefined, invalidated: boolean}}
      */
-    static computeValidLCPAllFrames(events: LH.TraceEvent[], timeOriginEvent: LH.TraceEvent): {
+    static computeValidLCPAllFrames(events: LH.TraceEvent[], timeOriginEvent: LH.TraceEvent, mainFrameId: string | undefined): {
         lcp: LCPEvent | undefined;
         invalidated: boolean;
     };
@@ -217,7 +218,7 @@ export class TraceProcessor {
      * @param {LH.Trace} trace
      * @param {{timeOriginDeterminationMethod?: TimeOriginDeterminationMethod}} [options]
      * @return {LH.Artifacts.ProcessedTrace}
-    */
+     */
     static processTrace(trace: LH.Trace, options?: {
         timeOriginDeterminationMethod?: TimeOriginDeterminationMethod;
     }): LH.Artifacts.ProcessedTrace;
@@ -226,7 +227,7 @@ export class TraceProcessor {
      * origin in addition to the standard microsecond monotonic timestamps.
      * @param {LH.Artifacts.ProcessedTrace} processedTrace
      * @return {LH.Artifacts.ProcessedNavigation}
-    */
+     */
     static processNavigation(processedTrace: LH.Artifacts.ProcessedTrace): LH.Artifacts.ProcessedNavigation;
     /**
      * Computes the last observable timestamp in a set of trace events.
@@ -272,7 +273,7 @@ export class TraceProcessor {
      * in addition to the standard microsecond monotonic timestamps.
      * @param {Array<LH.TraceEvent>} frameEvents
      * @param {{timeOriginEvt: LH.TraceEvent}} options
-    */
+     */
     static computeNavigationTimingsForFrame(frameEvents: Array<LH.TraceEvent>, options: {
         timeOriginEvt: LH.TraceEvent;
     }): {

package/core/lib/tracehouse/trace-processor.js

@@ -349,7 +349,7 @@ class TraceProcessor {
 
     const ret = this.getMainThreadTopLevelEventDurations(events, startTime, endTime);
     return this._riskPercentiles(ret.durations, totalTime, percentiles,
-        ret.clippedLength);
+      ret.clippedLength);
   }
 
   /**
@@ -479,9 +479,9 @@ class TraceProcessor {
     const firstResourceSendEvt = events.find(e => e.name === 'ResourceSendRequest');
     // We know that these properties exist if we found the events, but TSC doesn't.
     if (navStartEvt?.args?.data &&
-        firstResourceSendEvt &&
-        firstResourceSendEvt.pid === navStartEvt.pid &&
-        firstResourceSendEvt.tid === navStartEvt.tid) {
+      firstResourceSendEvt &&
+      firstResourceSendEvt.pid === navStartEvt.pid &&
+      firstResourceSendEvt.tid === navStartEvt.tid) {
       const frameId = navStartEvt.args.frame;
       if (frameId) {
         return {
@@ -552,9 +552,9 @@ class TraceProcessor {
    */
   static isScheduleableTask(evt) {
     return evt.name === SCHEDULABLE_TASK_TITLE_LH ||
-    evt.name === SCHEDULABLE_TASK_TITLE_ALT1 ||
-    evt.name === SCHEDULABLE_TASK_TITLE_ALT2 ||
-    evt.name === SCHEDULABLE_TASK_TITLE_ALT3;
+      evt.name === SCHEDULABLE_TASK_TITLE_ALT1 ||
+      evt.name === SCHEDULABLE_TASK_TITLE_ALT2 ||
+      evt.name === SCHEDULABLE_TASK_TITLE_ALT3;
   }
 
   /**
@@ -563,7 +563,7 @@ class TraceProcessor {
    */
   static isLCPEvent(evt) {
     if (evt.name !== 'largestContentfulPaint::Invalidate' &&
-        evt.name !== 'largestContentfulPaint::Candidate') return false;
+      evt.name !== 'largestContentfulPaint::Candidate') return false;
     return Boolean(evt.args?.frame);
   }
 
@@ -602,9 +602,10 @@ class TraceProcessor {
    *
    * @param {LH.TraceEvent[]} events
    * @param {LH.TraceEvent} timeOriginEvent
+   * @param {string|undefined} mainFrameId
    * @return {{lcp: LCPEvent | undefined, invalidated: boolean}}
    */
-  static computeValidLCPAllFrames(events, timeOriginEvent) {
+  static computeValidLCPAllFrames(events, timeOriginEvent, mainFrameId) {
     const lcpEvents = events.filter(this.isLCPEvent).reverse();
 
     /** @type {Map<string, LCPEvent>} */
@@ -628,6 +629,53 @@ class TraceProcessor {
       }
     }
 
+    // If no standard LCP candidate is found, try the UKM AllFramesEvents.
+    if (!maxLcpAcrossFrames) {
+      const ukmEvents = events.filter(
+        (e) =>
+          e.name.includes('LargestContentfulPaint') && e.name.includes('UKM')
+      );
+
+      // In the rare cases this whole fallback is necessary, the
+      // NavStartToLargestContentfulPaint::Candidate::AllFrames::UKM events are missing too.
+      // As a result, the only useful signal left is the AllFrames invalidates.
+      // Not ideal since they are 1 paint behind, but.. better than the dreaded
+      // NO_LCP error
+      const targetEventName =
+        'NavStartToLargestContentfulPaint::Invalidate::AllFrames::UKM';
+      const ukmInvalidates = ukmEvents.filter((e) => e.name === targetEventName);
+
+      if (ukmInvalidates.length > 0) {
+        ukmInvalidates.sort((a, b) => a.ts - b.ts);
+        const lastInvalidate = ukmInvalidates[ukmInvalidates.length - 1];
+
+        log.warn(
+          'TraceProcessor',
+          'LCP candidate missing, falling back to UKM Invalidate event.'
+        );
+
+        // Construct a mock LCP candidate event
+        maxLcpAcrossFrames = /** @type {LCPCandidateEvent} */ (
+          /** @type {unknown} */ ({
+            name: 'largestContentfulPaint::Candidate',
+            cat: 'loading',
+            ph: lastInvalidate.ph,
+            ts: lastInvalidate.ts,
+            pid: lastInvalidate.pid,
+            tid: lastInvalidate.tid,
+            args: {
+              frame: mainFrameId || 'main_frame', // Mocked frame ID
+              data: {
+                size: 1, // Don't know the actuall size so we assign it 1
+                isMainFrame: true,
+                isOutermostMainFrame: true,
+              },
+            },
+          })
+        );
+      }
+    }
+
     return {
       lcp: maxLcpAcrossFrames,
       // LCP events were found, but final LCP event of every frame was an invalidate event.
@@ -669,7 +717,7 @@ class TraceProcessor {
    * @param {LH.Trace} trace
    * @param {{timeOriginDeterminationMethod?: TimeOriginDeterminationMethod}} [options]
    * @return {LH.Artifacts.ProcessedTrace}
-  */
+   */
   static processTrace(trace, options) {
     const {timeOriginDeterminationMethod = 'auto'} = options || {};
 
@@ -677,9 +725,9 @@ class TraceProcessor {
     // *must* be stable to keep events correctly nested.
     const keyEvents = this.filteredTraceSort(trace.traceEvents, e => {
       return e.cat.includes('blink.user_timing') ||
-          e.cat.includes('loading') ||
-          e.cat.includes('devtools.timeline') ||
-          e.cat === '__metadata';
+        e.cat.includes('loading') ||
+        e.cat.includes('devtools.timeline') ||
+        e.cat === '__metadata';
     });
 
     // Find the inspected frame
@@ -699,7 +747,7 @@ class TraceProcessor {
     // Begin collection of frame tree information with TracingStartedInBrowser,
     // which should be present even without navigations.
     const tracingStartedFrames = keyEvents
-        .find(e => e.name === 'TracingStartedInBrowser')?.args?.data?.frames;
+      .find(e => e.name === 'TracingStartedInBrowser')?.args?.data?.frames;
     if (tracingStartedFrames) {
       for (const frame of tracingStartedFrames) {
         framesById.set(frame.frame, {
@@ -738,12 +786,18 @@ class TraceProcessor {
     // Filter to just events matching the main frame ID, just to make sure.
     /** @param {LH.TraceEvent} e */
     function associatedToMainFrame(e) {
+      if (e.name === 'NavStartToLargestContentfulPaint::Invalidate::AllFrames::UKM') {
+        return true;
+      }
       const frameId = TraceProcessor.getFrameId(e);
       return frameId === mainFrameInfo.frameId;
     }
 
     /** @param {LH.TraceEvent} e */
     function associatedToAllFrames(e) {
+      if (e.name.includes('LargestContentfulPaint') && e.name.includes('UKM')) {
+        return true;
+      }
       const frameId = TraceProcessor.getFrameId(e);
       return frameId ? inspectedTreeFrameIds.includes(frameId) : false;
     }
@@ -805,9 +859,16 @@ class TraceProcessor {
    * origin in addition to the standard microsecond monotonic timestamps.
    * @param {LH.Artifacts.ProcessedTrace} processedTrace
    * @return {LH.Artifacts.ProcessedNavigation}
-  */
+   */
   static processNavigation(processedTrace) {
-    const {frameEvents, frameTreeEvents, timeOriginEvt, timings, timestamps} = processedTrace;
+    const {
+      frameEvents,
+      frameTreeEvents,
+      timeOriginEvt,
+      timings,
+      timestamps,
+      mainFrameInfo,
+    } = processedTrace;
 
     // Compute the key frame timings for the main frame.
     const frameTimings = this.computeNavigationTimingsForFrame(frameEvents, {timeOriginEvt});
@@ -822,7 +883,11 @@ class TraceProcessor {
     }
 
     // Compute LCP for all frames.
-    const lcpAllFramesEvt = this.computeValidLCPAllFrames(frameTreeEvents, timeOriginEvt).lcp;
+    const lcpAllFramesEvt = this.computeValidLCPAllFrames(
+      frameTreeEvents,
+      timeOriginEvt,
+      mainFrameInfo.frameId
+    ).lcp;
 
     /** @param {number} ts */
     const getTiming = ts => (ts - timeOriginEvt.ts) / 1000;
@@ -950,7 +1015,7 @@ class TraceProcessor {
    * in addition to the standard microsecond monotonic timestamps.
    * @param {Array<LH.TraceEvent>} frameEvents
    * @param {{timeOriginEvt: LH.TraceEvent}} options
-  */
+   */
   static computeNavigationTimingsForFrame(frameEvents, options) {
     const {timeOriginEvt} = options;
 
@@ -967,7 +1032,8 @@ class TraceProcessor {
     }
 
     // This function accepts events spanning multiple frames, but this usage will only provide events from the main frame.
-    const lcpResult = this.computeValidLCPAllFrames(frameEvents, timeOriginEvt);
+    const frameId = frameEvents.map(e => TraceProcessor.getFrameId(e)).find(Boolean);
+    const lcpResult = this.computeValidLCPAllFrames(frameEvents, timeOriginEvt, frameId);
 
     const load = frameEvents.find(e => e.name === 'loadEventEnd' && e.ts > timeOriginEvt.ts);
     const domContentLoaded = frameEvents.find(