lighthouse 12.8.2-dev.20251006 → 12.8.2-dev.20251008

package/core/audits/insights/dom-size-insight.js

@@ -85,7 +85,11 @@ class DOMSizeInsight extends Audit {
         maxChildren: maxChildren.numChildren,
         maxDepth: maxDepth.depth,
       };
-      return details;
+      return {
+        details,
+        numericValue: totalElements,
+        numericUnit: 'element',
+      };
     });
   }
 }

package/core/audits/insights/font-display-insight.js

@@ -46,7 +46,9 @@ class FontDisplayInsight extends Audit {
         url: font.request.args.data.url,
         wastedMs: font.wastedTime,
       }));
-      return Audit.makeTableDetails(headings, items);
+      const details = Audit.makeTableDetails(headings, items);
+      details.skipSumming = ['wastedMs'];
+      return details;
     });
   }
 }

package/core/audits/insights/insight-audit.d.ts

@@ -11,13 +11,15 @@ export type CreateDetailsExtras = {
  * @param {LH.Artifacts} artifacts
  * @param {LH.Audit.Context} context
  * @param {T} insightName
- * @param {(insight: import('@paulirish/trace_engine/models/trace/insights/types.js').InsightModels[T], extras: CreateDetailsExtras) => {details: LH.Audit.Details, warnings: Array<string | LH.IcuMessage>}|LH.Audit.Details|undefined} createDetails
+ * @param {(insight: import('@paulirish/trace_engine/models/trace/insights/types.js').InsightModels[T], extras: CreateDetailsExtras) => {details: LH.Audit.Details, warnings?: Array<string | LH.IcuMessage>, numericValue?: number, numericUnit?: LH.Audit.NumericProduct['numericUnit']}|LH.Audit.Details|undefined} createDetails
  * @template {keyof import('@paulirish/trace_engine/models/trace/insights/types.js').InsightModelsType} T
  * @return {Promise<LH.Audit.Product>}
  */
 export function adaptInsightToAuditProduct<T extends keyof import("@paulirish/trace_engine/models/trace/insights/types.js").InsightModelsType>(artifacts: LH.Artifacts, context: LH.Audit.Context, insightName: T, createDetails: (insight: import("@paulirish/trace_engine/models/trace/insights/types.js").InsightModels[T], extras: CreateDetailsExtras) => {
     details: LH.Audit.Details;
-    warnings: Array<string | LH.IcuMessage>;
+    warnings?: Array<string | LH.IcuMessage>;
+    numericValue?: number;
+    numericUnit?: LH.Audit.NumericProduct["numericUnit"];
 } | LH.Audit.Details | undefined): Promise<LH.Audit.Product>;
 /**
  * @param {LH.Artifacts.TraceElement[]} traceElements

package/core/audits/insights/insight-audit.js

@@ -42,7 +42,7 @@ async function getInsightSet(artifacts, context) {
  * @param {LH.Artifacts} artifacts
  * @param {LH.Audit.Context} context
  * @param {T} insightName
- * @param {(insight: import('@paulirish/trace_engine/models/trace/insights/types.js').InsightModels[T], extras: CreateDetailsExtras) => {details: LH.Audit.Details, warnings: Array<string | LH.IcuMessage>}|LH.Audit.Details|undefined} createDetails
+ * @param {(insight: import('@paulirish/trace_engine/models/trace/insights/types.js').InsightModels[T], extras: CreateDetailsExtras) => {details: LH.Audit.Details, warnings?: Array<string | LH.IcuMessage>, numericValue?: number, numericUnit?: LH.Audit.NumericProduct['numericUnit']}|LH.Audit.Details|undefined} createDetails
  * @template {keyof import('@paulirish/trace_engine/models/trace/insights/types.js').InsightModelsType} T
  * @return {Promise<LH.Audit.Product>}
  */
@@ -70,11 +70,17 @@ async function adaptInsightToAuditProduct(artifacts, context, insightName, creat
   });
 
   const warnings = [...insight.warnings ?? []];
+  /** @type {number|undefined} */
+  let numericValue;
+  /** @type {LH.Audit.NumericProduct['numericUnit']|undefined} */
+  let numericUnit;
 
   let details;
-  if (cbResult && 'warnings' in cbResult) {
+  if (cbResult && 'details' in cbResult) {
     details = cbResult.details;
-    warnings.push(...cbResult.warnings);
+    if (cbResult.warnings) warnings.push(...cbResult.warnings);
+    numericValue = cbResult.numericValue;
+    numericUnit = cbResult.numericUnit;
   } else {
     details = cbResult;
   }
@@ -163,6 +169,19 @@ async function adaptInsightToAuditProduct(artifacts, context, insightName, creat
     scoreDisplayMode = Audit.SCORING_MODES.INFORMATIVE;
   }
 
+  if (numericValue !== undefined && numericUnit !== undefined) {
+    return {
+      scoreDisplayMode,
+      score,
+      numericValue,
+      numericUnit,
+      metricSavings,
+      warnings: warnings.length ? warnings : undefined,
+      displayValue,
+      details,
+    };
+  }
+
   return {
     scoreDisplayMode,
     score,

package/core/audits/predictive-perf.js

@@ -76,8 +76,8 @@ class PredictivePerf extends Audit {
       pessimisticLCP: lcp.pessimisticEstimate.timeInMs,
 
       roughEstimateOfTTFB: timingSummary.metrics.timeToFirstByte,
-      roughEstimateOfLCPLoadStart: timingSummary.metrics.lcpLoadStart,
-      roughEstimateOfLCPLoadEnd: timingSummary.metrics.lcpLoadEnd,
+      roughEstimateOfLCPLoadStart: timingSummary.metrics.lcpLoadDelay,
+      roughEstimateOfLCPLoadEnd: timingSummary.metrics.lcpLoadDuration,
     };
 
     const score = Audit.computeLogNormalScore(

package/core/audits/redirects.js

@@ -89,7 +89,6 @@ class Redirects extends Audit {
     const gatherContext = artifacts.GatherContext;
     const {URL, SourceMaps} = artifacts;
 
-    // TODO(v13): use trace processor / network tree insight.
     const processedTrace = await ProcessedTrace.request(trace, context);
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
     const documentRequests = Redirects.getDocumentRequestChain(networkRecords, processedTrace);

package/core/audits/seo/crawlable-anchors.js

@@ -57,12 +57,10 @@ class CrawlableAnchors extends Audit {
       href,
       attributeNames = [],
       listeners = [],
-      ancestorListeners = [],
     }) => {
       rawHref = rawHref.replace( /\s/g, '');
       name = name.trim();
       role = role.trim();
-      const hasListener = Boolean(listeners.length || ancestorListeners.length);
 
       if (role.length > 0) return;
       // Ignore mailto links even if they use one of the failing patterns. See https://github.com/GoogleChrome/lighthouse/issues/11443#issuecomment-694898412
@@ -86,7 +84,8 @@ class CrawlableAnchors extends Audit {
         !attributeNames.includes('href') &&
         hrefAssociatedAttributes.every(attribute => !attributeNames.includes(attribute))
       ) {
-        return hasListener;
+        // If it has an even listener (e.g. onclick) then we can't assume it's a placeholder. Therefore we consider it failing.
+        return Boolean(listeners.length);
       }
 
       if (href === '') return true;

package/core/computed/metrics/lcp-breakdown.d.ts

@@ -2,20 +2,25 @@ export { LCPBreakdownComputed as LCPBreakdown };
 declare const LCPBreakdownComputed: typeof LCPBreakdown & {
     request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext) => Promise<{
         ttfb: number;
-        loadStart?: number;
-        loadEnd?: number;
+        loadDelay?: number;
+        loadDuration?: number;
+        renderDelay?: number;
     }>;
 };
+/**
+ * Note: this omits renderDelay for simulated throttling.
+ */
 declare class LCPBreakdown {
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} data
      * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<{ttfb: number, loadStart?: number, loadEnd?: number}>}
+     * @return {Promise<{ttfb: number, loadDelay?: number, loadDuration?: number, renderDelay?: number}>}
      */
     static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<{
         ttfb: number;
-        loadStart?: number;
-        loadEnd?: number;
+        loadDelay?: number;
+        loadDuration?: number;
+        renderDelay?: number;
     }>;
 }
 //# sourceMappingURL=lcp-breakdown.d.ts.map

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

@@ -10,43 +10,70 @@ import {LargestContentfulPaint} from './largest-contentful-paint.js';
 import {ProcessedNavigation} from '../processed-navigation.js';
 import {TimeToFirstByte} from './time-to-first-byte.js';
 import {LCPImageRecord} from '../lcp-image-record.js';
+import {NavigationInsights} from '../navigation-insights.js';
 
-// TODO(v13): should use LCPBreakdown insight
+/**
+ * Note: this omits renderDelay for simulated throttling.
+ */
 class LCPBreakdown {
   /**
    * @param {LH.Artifacts.MetricComputationDataInput} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<{ttfb: number, loadStart?: number, loadEnd?: number}>}
+   * @return {Promise<{ttfb: number, loadDelay?: number, loadDuration?: number, renderDelay?: number}>}
    */
   static async compute_(data, context) {
-    const processedNavigation = await ProcessedNavigation.request(data.trace, context);
-    const observedLcp = processedNavigation.timings.largestContentfulPaint;
-    if (observedLcp === undefined) {
-      throw new LighthouseError(LighthouseError.errors.NO_LCP);
-    }
-    const timeOrigin = processedNavigation.timestamps.timeOrigin / 1000;
+    if (data.settings.throttlingMethod === 'simulate') {
+      const processedNavigation = await ProcessedNavigation.request(data.trace, context);
+      const observedLcp = processedNavigation.timings.largestContentfulPaint;
+      if (observedLcp === undefined) {
+        throw new LighthouseError(LighthouseError.errors.NO_LCP);
+      }
+      const timeOrigin = processedNavigation.timestamps.timeOrigin / 1000;
 
-    const {timing: ttfb} = await TimeToFirstByte.request(data, context);
+      const {timing: ttfb} = await TimeToFirstByte.request(data, context);
 
-    const lcpRecord = await LCPImageRecord.request(data, context);
-    if (!lcpRecord) {
-      return {ttfb};
-    }
+      const lcpRecord = await LCPImageRecord.request(data, context);
+      if (!lcpRecord) {
+        return {ttfb};
+      }
+
+      // Official LCP^tm. Will be lantern result if simulated, otherwise same as observedLcp.
+      const {timing: metricLcp} = await LargestContentfulPaint.request(data, context);
+      const throttleRatio = metricLcp / observedLcp;
 
-    // Official LCP^tm. Will be lantern result if simulated, otherwise same as observedLcp.
-    const {timing: metricLcp} = await LargestContentfulPaint.request(data, context);
-    const throttleRatio = metricLcp / observedLcp;
+      const unclampedLoadStart = (lcpRecord.networkRequestTime - timeOrigin) * throttleRatio;
+      const loadDelay = Math.max(ttfb, Math.min(unclampedLoadStart, metricLcp));
 
-    const unclampedLoadStart = (lcpRecord.networkRequestTime - timeOrigin) * throttleRatio;
-    const loadStart = Math.max(ttfb, Math.min(unclampedLoadStart, metricLcp));
+      const unclampedLoadEnd = (lcpRecord.networkEndTime - timeOrigin) * throttleRatio;
+      const loadDuration = Math.max(loadDelay, Math.min(unclampedLoadEnd, metricLcp));
 
-    const unclampedLoadEnd = (lcpRecord.networkEndTime - timeOrigin) * throttleRatio;
-    const loadEnd = Math.max(loadStart, Math.min(unclampedLoadEnd, metricLcp));
+      return {
+        ttfb,
+        loadDelay,
+        loadDuration,
+      };
+    }
+
+    const {trace, settings, SourceMaps} = data;
+    const navInsights = await NavigationInsights.request({trace, settings, SourceMaps}, context);
+    const lcpBreakdown = navInsights.model.LCPBreakdown;
+    if (lcpBreakdown instanceof Error) {
+      throw new LighthouseError(LighthouseError.errors.NO_LCP, {}, {cause: lcpBreakdown});
+    }
+
+    if (!lcpBreakdown.subparts) {
+      throw new LighthouseError(LighthouseError.errors.NO_LCP);
+    }
 
     return {
-      ttfb,
-      loadStart,
-      loadEnd,
+      ttfb: lcpBreakdown.subparts.ttfb.range / 1000,
+      loadDelay: lcpBreakdown.subparts.loadDelay !== undefined ?
+        lcpBreakdown.subparts.loadDelay.range / 1000 :
+        undefined,
+      loadDuration: lcpBreakdown.subparts.loadDuration !== undefined ?
+        lcpBreakdown.subparts.loadDuration.range / 1000 :
+        undefined,
+      renderDelay: lcpBreakdown.subparts.renderDelay.range / 1000,
     };
   }
 }

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

@@ -4,10 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import {calculateDocFirstByteTs} from '@paulirish/trace_engine/models/trace/insights/Common.js';
+
 import {makeComputedArtifact} from '../computed-artifact.js';
 import {NavigationMetric} from './navigation-metric.js';
 import {MainResource} from '../main-resource.js';
 import {NetworkAnalysis} from '../network-analysis.js';
+import {NavigationInsights} from '../navigation-insights.js';
+import {TraceEngineResult} from '../trace-engine-result.js';
 
 class TimeToFirstByte extends NavigationMetric {
   /**
@@ -41,18 +45,37 @@ class TimeToFirstByte extends NavigationMetric {
    * @return {Promise<LH.Artifacts.Metric>}
    */
   static async computeObservedMetric(data, context) {
-    const mainResource = await MainResource.request(data, context);
-    if (!mainResource.timing) {
-      throw new Error('missing timing for main resource');
+    const {trace, settings, SourceMaps} = data;
+    const traceEngineResult =
+      await TraceEngineResult.request({trace, settings, SourceMaps}, context);
+    const navInsights = await NavigationInsights.request({trace, settings, SourceMaps}, context);
+    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) {
+      return {
+        timing: lcpBreakdown.subparts.ttfb.range / 1000,
+        timestamp: lcpBreakdown.subparts.ttfb.max,
+      };
+    } else if (navInsights.navigation?.args.data?.navigationId) {
+      const request = traceEngineResult.data.NetworkRequests.byId.get(
+        navInsights.navigation.args.data.navigationId);
+      if (!request) {
+        throw new Error();
+      }
+
+      const timestamp = calculateDocFirstByteTs(request);
+      if (timestamp === null) {
+        throw new Error('cannot calculate ttfb');
+      }
+
+      return {
+        timing: (timestamp - navInsights.navigation.ts) / 1000,
+        timestamp,
+      };
     }
 
-    const {processedNavigation} = data;
-    const timeOriginTs = processedNavigation.timestamps.timeOrigin;
-    const timestampMs =
-      mainResource.timing.requestTime * 1000 + mainResource.timing.receiveHeadersStart;
-    const timestamp = timestampMs * 1000;
-    const timing = (timestamp - timeOriginTs) / 1000;
-    return {timing, timestamp};
+    throw new Error('cannot determine ttfb');
   }
 }
 

package/core/computed/metrics/timing-summary.js

@@ -96,8 +96,9 @@ class TimingSummary {
       cumulativeLayoutShift,
       cumulativeLayoutShiftMainFrame,
 
-      lcpLoadStart: lcpBreakdown?.loadStart,
-      lcpLoadEnd: lcpBreakdown?.loadEnd,
+      lcpLoadDelay: lcpBreakdown?.loadDelay,
+      lcpLoadDuration: lcpBreakdown?.loadDuration,
+      lcpRenderDelay: lcpBreakdown?.renderDelay,
 
       timeToFirstByte: ttfb?.timing,
       timeToFirstByteTs: ttfb?.timestamp,

package/core/config/default-config.js

@@ -114,11 +114,9 @@ const defaultConfig = {
 
     {id: 'Accessibility', gatherer: 'accessibility'},
     {id: 'AnchorElements', gatherer: 'anchor-elements'},
-    {id: 'CacheContents', gatherer: 'cache-contents'},
     {id: 'ConsoleMessages', gatherer: 'console-messages'},
     {id: 'CSSUsage', gatherer: 'css-usage'},
     {id: 'Doctype', gatherer: 'dobetterweb/doctype'},
-    {id: 'DOMStats', gatherer: 'dobetterweb/domstats'},
     {id: 'Inputs', gatherer: 'inputs'},
     {id: 'IFrameElements', gatherer: 'iframe-elements'},
     {id: 'ImageElements', gatherer: 'image-elements'},
@@ -128,8 +126,6 @@ const defaultConfig = {
     {id: 'MainDocumentContent', gatherer: 'main-document-content'},
     {id: 'MetaElements', gatherer: 'meta-elements'},
     {id: 'NetworkUserAgent', gatherer: 'network-user-agent'},
-    {id: 'OptimizedImages', gatherer: 'dobetterweb/optimized-images'},
-    {id: 'ResponseCompression', gatherer: 'dobetterweb/response-compression'},
     {id: 'RobotsTxt', gatherer: 'seo/robots-txt'},
     {id: 'Scripts', gatherer: 'scripts'},
     {id: 'SourceMaps', gatherer: 'source-maps'},
@@ -149,7 +145,6 @@ const defaultConfig = {
     'redirects-http',
     'metrics/first-contentful-paint',
     'metrics/largest-contentful-paint',
-    'metrics/first-meaningful-paint',
     'metrics/speed-index',
     'screenshot-thumbnails',
     'final-screenshot',
@@ -260,7 +255,6 @@ const defaultConfig = {
     'accessibility/manual/use-landmarks',
     'accessibility/manual/visual-order-follows-dom',
     'byte-efficiency/total-byte-weight',
-    'byte-efficiency/offscreen-images',
     'byte-efficiency/unminified-css',
     'byte-efficiency/unminified-javascript',
     'byte-efficiency/unused-css-rules',
@@ -269,11 +263,9 @@ const defaultConfig = {
     'dobetterweb/charset',
     'dobetterweb/geolocation-on-start',
     'dobetterweb/inspector-issues',
-    'dobetterweb/no-document-write',
     'dobetterweb/js-libraries',
     'dobetterweb/notification-on-start',
     'dobetterweb/paste-preventing-inputs',
-    'dobetterweb/uses-passive-event-listeners',
     'seo/meta-description',
     'seo/http-status-code',
     'seo/link-text',
@@ -407,9 +399,7 @@ const defaultConfig = {
         // These are our "invisible" metrics. Not displayed, but still in the LHR.
         {id: 'interactive', weight: 0, group: 'hidden', acronym: 'TTI'},
         {id: 'max-potential-fid', weight: 0, group: 'hidden'},
-        {id: 'first-meaningful-paint', weight: 0, acronym: 'FMP', group: 'hidden'},
 
-        {id: 'offscreen-images', weight: 0, group: 'diagnostics'},
         {id: 'unminified-css', weight: 0, group: 'diagnostics'},
         {id: 'unminified-javascript', weight: 0, group: 'diagnostics'},
         {id: 'unused-css-rules', weight: 0, group: 'diagnostics'},
@@ -418,8 +408,6 @@ const defaultConfig = {
         {id: 'user-timings', weight: 0, group: 'diagnostics'},
         {id: 'bootup-time', weight: 0, group: 'diagnostics'},
         {id: 'mainthread-work-breakdown', weight: 0, group: 'diagnostics'},
-        {id: 'uses-passive-event-listeners', weight: 0, group: 'diagnostics'},
-        {id: 'no-document-write', weight: 0, group: 'diagnostics'},
         {id: 'long-tasks', weight: 0, group: 'diagnostics'},
         {id: 'non-composited-animations', weight: 0, group: 'diagnostics'},
         {id: 'unsized-images', weight: 0, group: 'diagnostics'},

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

@@ -157,33 +157,17 @@ class AnchorElements extends BaseGatherer {
 
     // DOM.getDocument is necessary for pushNodesByBackendIdsToFrontend to properly retrieve nodeIds if the `DOM` domain was enabled before this gatherer, invoke it to be safe.
     await session.sendCommand('DOM.getDocument', {depth: -1, pierce: true});
-    const anchorsWithEventListeners = anchors.map(async anchor => {
-      const listeners = await getEventListeners(session, anchor.node.devtoolsNodePath);
-
-      /** @type {Set<{type: string}>} */
-      const ancestorListeners = new Set();
-      const splitPath = anchor.node.devtoolsNodePath.split(',');
-      const ancestorListenerPromises = [];
-      while (splitPath.length >= 2) {
-        splitPath.length -= 2;
-        const path = splitPath.join(',');
-        const promise = getEventListeners(session, path).then(listeners => {
-          for (const listener of listeners) {
-            ancestorListeners.add(listener);
-          }
-        }).catch(() => {});
-        ancestorListenerPromises.push(promise);
-      }
-
-      await Promise.all(ancestorListenerPromises);
 
-      return {
-        ...anchor,
-        listeners,
-        ancestorListeners: Array.from(ancestorListeners),
-      };
+    const anchorsWithEventListeners = anchors.map( anchor => {
+      return getEventListeners(session, anchor.node.devtoolsNodePath).then(listeners => {
+        return {
+          ...anchor,
+          listeners,
+        };
+      });
     });
 
+
     const result = await Promise.all(anchorsWithEventListeners);
     await session.sendCommand('DOM.disable');
     return result;

package/core/gather/gatherers/inspector-issues.js

@@ -61,34 +61,7 @@ class InspectorIssues extends BaseGatherer {
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
 
     /** @type {LH.Artifacts.InspectorIssues} */
-    const artifact = {
-      // TODO(v13): remove empty arrays.
-      attributionReportingIssue: [],
-      blockedByResponseIssue: [],
-      bounceTrackingIssue: [],
-      clientHintIssue: [],
-      contentSecurityPolicyIssue: [],
-      cookieDeprecationMetadataIssue: [],
-      corsIssue: [],
-      deprecationIssue: [],
-      federatedAuthRequestIssue: [],
-      genericIssue: [],
-      heavyAdIssue: [],
-      lowTextContrastIssue: [],
-      mixedContentIssue: [],
-      navigatorUserAgentIssue: [],
-      partitioningBlobURLIssue: [],
-      propertyRuleIssue: [],
-      quirksModeIssue: [],
-      cookieIssue: [],
-      elementAccessibilityIssue: [],
-      sharedArrayBufferIssue: [],
-      sharedDictionaryIssue: [],
-      stylesheetLoadingIssue: [],
-      sriMessageSignatureIssue: [],
-      federatedAuthUserInfoRequestIssue: [],
-      userReidentificationIssue: [],
-    };
+    const artifact = {};
 
     for (const issue of this._issues) {
       const detailsKey = /** @type {keyof LH.Crdp.Audits.InspectorIssueDetails} */(

package/core/gather/gatherers/trace-elements.d.ts

@@ -45,15 +45,6 @@ declare class TraceElements extends BaseGatherer {
      * @return {Promise<TraceElementData|undefined>}
      */
     static getResponsivenessElement(trace: LH.Trace, context: LH.Gatherer.Context): Promise<TraceElementData | undefined>;
-    /**
-     * @param {LH.Trace} trace
-     * @param {LH.Gatherer.Context} context
-     * @return {Promise<{nodeId: number, type: string} | undefined>}
-     */
-    static getLcpElement(trace: LH.Trace, context: LH.Gatherer.Context): Promise<{
-        nodeId: number;
-        type: string;
-    } | undefined>;
     /** @type {LH.Gatherer.GathererMeta<'Trace'|'SourceMaps'>} */
     meta: LH.Gatherer.GathererMeta<"Trace" | "SourceMaps">;
     /** @type {Map<string, string>} */

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

@@ -18,8 +18,6 @@ import {pageFunctions} from '../../lib/page-functions.js';
 import {Sentry} from '../../lib/sentry.js';
 import Trace from './trace.js';
 import {ProcessedTrace} from '../../computed/processed-trace.js';
-import {ProcessedNavigation} from '../../computed/processed-navigation.js';
-import {LighthouseError} from '../../lib/lh-error.js';
 import {Responsiveness} from '../../computed/metrics/responsiveness.js';
 import {CumulativeLayoutShift} from '../../computed/metrics/cumulative-layout-shift.js';
 import {ExecutionContext} from '../driver/execution-context.js';
@@ -276,35 +274,6 @@ class TraceElements extends BaseGatherer {
     return animatedElementData;
   }
 
-  /**
-   * @param {LH.Trace} trace
-   * @param {LH.Gatherer.Context} context
-   * @return {Promise<{nodeId: number, type: string} | undefined>}
-   */
-  static async getLcpElement(trace, context) {
-    let processedNavigation;
-    try {
-      processedNavigation = await ProcessedNavigation.request(trace, context);
-    } catch (err) {
-      // If we were running in timespan mode and there was no paint, treat LCP as missing.
-      if (context.gatherMode === 'timespan' && err.code === LighthouseError.errors.NO_FCP.code) {
-        return;
-      }
-
-      throw err;
-    }
-
-    // Use main-frame-only LCP to match the metric value.
-    const lcpData = processedNavigation.largestContentfulPaintEvt?.args?.data;
-    // These should exist, but trace types are loose.
-    if (lcpData?.nodeId === undefined || !lcpData.type) return;
-
-    return {
-      nodeId: lcpData.nodeId,
-      type: lcpData.type,
-    };
-  }
-
   /**
    * @param {LH.Gatherer.Context} context
    */
@@ -372,20 +341,15 @@ class TraceElements extends BaseGatherer {
 
     const traceEngineData = await TraceElements.getTraceEngineElements(
       traceEngineResult, navigationId);
-    const lcpNodeData = await TraceElements.getLcpElement(trace, context);
     const shiftsData = await TraceElements.getTopLayoutShifts(
       trace, traceEngineResult, context);
     const animatedElementData = await this.getAnimatedElements(mainThreadEvents);
-    const responsivenessElementData = await TraceElements.getResponsivenessElement(trace, context);
 
-    // TODO(v13): remove unnecessary entries.
     /** @type {Map<string, TraceElementData[]>} */
     const backendNodeDataMap = new Map([
       ['trace-engine', traceEngineData],
-      ['largest-contentful-paint', lcpNodeData ? [lcpNodeData] : []],
       ['layout-shift', shiftsData],
       ['animation', animatedElementData],
-      ['responsiveness', responsivenessElementData ? [responsivenessElementData] : []],
     ]);
 
     /** @type {Map<number, LH.Crdp.Runtime.CallFunctionOnResponse | null>} */

package/core/lib/network-request.d.ts

@@ -241,13 +241,6 @@ export class NetworkRequest {
      * LR loses protocol information.
      */
     _updateProtocolForLightrider(): void;
-    /**
-     * TODO(compat): remove M116.
-     * `timing.receiveHeadersStart` was added recently, and will be in M116. Until then,
-     * set it to receiveHeadersEnd, which is close enough, to allow consumers of NetworkRequest
-     * to use the new field without accounting for this backcompat.
-     */
-    _backfillReceiveHeaderStartTiming(): void;
     /**
      * LR gets additional, accurate timing information from its underlying fetch infrastructure.  This
      * is passed in via X-Headers similar to 'X-TotalFetchedSize'.

package/core/lib/network-request.js

@@ -286,7 +286,6 @@ class NetworkRequest {
     }
 
     this._updateResponseHeadersEndTimeIfNecessary();
-    this._backfillReceiveHeaderStartTiming();
     this._updateTransferSizeForLightrider();
     this._updateTimingsForLightrider();
   }
@@ -306,7 +305,6 @@ class NetworkRequest {
     this.localizedFailDescription = data.errorText;
 
     this._updateResponseHeadersEndTimeIfNecessary();
-    this._backfillReceiveHeaderStartTiming();
     this._updateTransferSizeForLightrider();
     this._updateTimingsForLightrider();
   }
@@ -329,7 +327,6 @@ class NetworkRequest {
     this.networkEndTime = data.timestamp * 1000;
 
     this._updateResponseHeadersEndTimeIfNecessary();
-    this._backfillReceiveHeaderStartTiming();
   }
 
   /**
@@ -463,19 +460,6 @@ class NetworkRequest {
     }
   }
 
-  /**
-   * TODO(compat): remove M116.
-   * `timing.receiveHeadersStart` was added recently, and will be in M116. Until then,
-   * set it to receiveHeadersEnd, which is close enough, to allow consumers of NetworkRequest
-   * to use the new field without accounting for this backcompat.
-   */
-  _backfillReceiveHeaderStartTiming() {
-    // Do nothing if a value is already present!
-    if (!this.timing || this.timing.receiveHeadersStart !== undefined) return;
-
-    this.timing.receiveHeadersStart = this.timing.receiveHeadersEnd;
-  }
-
   /**
    * LR gets additional, accurate timing information from its underlying fetch infrastructure.  This
    * is passed in via X-Headers similar to 'X-TotalFetchedSize'.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "12.8.2-dev.20251006",
+  "version": "12.8.2-dev.20251008",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {
@@ -181,7 +181,7 @@
     "webtreemap-cdt": "^3.2.1"
   },
   "dependencies": {
-    "@paulirish/trace_engine": "0.0.60",
+    "@paulirish/trace_engine": "0.0.61",
     "@sentry/node": "^9.28.1",
     "axe-core": "^4.10.3",
     "chrome-launcher": "^1.2.1",
@@ -197,9 +197,7 @@
     "lighthouse-stack-packs": "1.12.3",
     "lodash-es": "^4.17.21",
     "lookup-closest-locale": "6.2.0",
-    "metaviewport-parser": "0.3.0",
     "open": "^8.4.0",
-    "parse-cache-control": "1.0.1",
     "puppeteer-core": "^24.23.0",
     "robots-parser": "^3.0.1",
     "speedline-core": "^1.4.3",