lighthouse 12.8.2-dev.20251005 → 12.8.2-dev.20251007

package/cli/test/smokehouse/config/exclusions.js

@@ -36,8 +36,6 @@ const exclusions = {
 for (const array of Object.values(exclusions)) {
   // https://github.com/GoogleChrome/lighthouse/issues/14271
   array.push('lantern-idle-callback-short');
-  // https://github.com/GoogleChrome/lighthouse/issues/16597
-  array.push('csp-block-all');
   // glitch is gone.
   array.push('issues-mixed-content');
   // works most of the time, but since it uses a live site it can be flaky

package/core/audits/audit.js

@@ -484,7 +484,6 @@ class Audit {
 
       details: product.details,
       guidanceLevel: audit.meta.guidanceLevel,
-      replacesAudits: audit.meta.replacesAudits,
     };
   }
 

package/core/audits/insights/cls-culprits-insight.js

@@ -38,7 +38,7 @@ class CLSCulpritsInsight extends Audit {
       description: insightStr_(InsightUIStrings.description),
       guidanceLevel: 3,
       requiredArtifacts: ['Trace', 'TraceElements', 'SourceMaps'],
-      replacesAudits: ['layout-shifts', 'non-composited-animations', 'unsized-images'],
+      replacesAudits: ['layout-shifts'],
     };
   }
 

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

@@ -59,21 +59,21 @@ class DOMSizeInsight extends Audit {
           },
         },
         {
-          statistic: str_(UIStrings.maxChildren),
-          node: makeNodeItemForNodeId(artifacts.TraceElements, maxChildren.nodeId),
+          statistic: str_(UIStrings.maxDOMDepth),
+          node: makeNodeItemForNodeId(artifacts.TraceElements, maxDepth.nodeId),
           value: {
             type: 'numeric',
             granularity: 1,
-            value: maxChildren.numChildren,
+            value: maxDepth.depth,
           },
         },
         {
-          statistic: str_(UIStrings.maxDOMDepth),
-          node: makeNodeItemForNodeId(artifacts.TraceElements, maxDepth.nodeId),
+          statistic: str_(UIStrings.maxChildren),
+          node: makeNodeItemForNodeId(artifacts.TraceElements, maxChildren.nodeId),
           value: {
             type: 'numeric',
             granularity: 1,
-            value: maxDepth.depth,
+            value: maxChildren.numChildren,
           },
         },
       ];
@@ -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/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/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/audits/server-response-time.d.ts

@@ -1,10 +1,5 @@
 export default ServerResponseTime;
 declare class ServerResponseTime extends Audit {
-    /**
-     * @param {LH.Artifacts.NetworkRequest} record
-     * @return {number|null}
-     */
-    static calculateResponseTime(record: LH.Artifacts.NetworkRequest): number | null;
     /**
      * @param {LH.Artifacts} artifacts
      * @param {LH.Audit.Context} context

package/core/audits/server-response-time.js

@@ -6,7 +6,7 @@
 
 import {Audit} from './audit.js';
 import * as i18n from '../lib/i18n/i18n.js';
-import {MainResource} from '../computed/main-resource.js';
+import {NavigationInsights} from '../computed/navigation-insights.js';
 
 const UIStrings = {
   /** Title of a diagnostic audit that provides detail on how long it took from starting a request to when the server started responding. This descriptive title is shown to users when the amount is acceptable and no user action is required. */
@@ -21,9 +21,6 @@ const UIStrings = {
 
 const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
 
-// Due to the way that DevTools throttling works we cannot see if server response took less than ~570ms.
-// We set our failure threshold to 600ms to avoid those false positives but we want devs to shoot for 100ms.
-const TOO_SLOW_THRESHOLD_MS = 600;
 const TARGET_MS = 100;
 
 class ServerResponseTime extends Audit {
@@ -38,41 +35,30 @@ class ServerResponseTime extends Audit {
       description: str_(UIStrings.description),
       supportedModes: ['navigation'],
       guidanceLevel: 1,
-      requiredArtifacts: ['DevtoolsLog', 'URL', 'GatherContext'],
+      requiredArtifacts: ['Trace', 'SourceMaps'],
       scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
     };
   }
 
-  /**
-   * @param {LH.Artifacts.NetworkRequest} record
-   * @return {number|null}
-   */
-  static calculateResponseTime(record) {
-    // Lightrider does not have timings for sendEnd, but we do have this timing which should be
-    // close to the response time.
-    if (global.isLightrider && record.lrStatistics) return record.lrStatistics.requestMs;
-
-    if (!record.timing) return null;
-    return record.timing.receiveHeadersStart - record.timing.sendEnd;
-  }
-
   /**
    * @param {LH.Artifacts} artifacts
    * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
   static async audit(artifacts, context) {
-    const devtoolsLog = artifacts.DevtoolsLog;
-
-    /** @type {LH.Artifacts.NetworkRequest} */
-    const mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
+    const settings = context.settings;
+    const trace = artifacts.Trace;
+    const SourceMaps = artifacts.SourceMaps;
+    const navInsights = await NavigationInsights.request({trace, settings, SourceMaps}, context);
+    const responseTime = navInsights.model.DocumentLatency.data?.serverResponseTime;
+    const url = navInsights.model.DocumentLatency.data?.documentRequest?.args.data.url;
 
-    const responseTime = ServerResponseTime.calculateResponseTime(mainResource);
-    if (responseTime === null) {
+    if (responseTime === undefined || !url) {
       throw new Error('no timing found for main resource');
     }
 
-    const passed = responseTime < TOO_SLOW_THRESHOLD_MS;
+    const passed =
+      Boolean(navInsights.model.DocumentLatency.data?.checklist.serverResponseIsFast.value);
     const displayValue = str_(UIStrings.displayValue, {timeInMs: responseTime});
 
     /** @type {LH.Audit.Details.Opportunity['headings']} */
@@ -84,7 +70,7 @@ class ServerResponseTime extends Audit {
     const overallSavingsMs = Math.max(responseTime - TARGET_MS, 0);
     const details = Audit.makeOpportunityDetails(
       headings,
-      [{url: mainResource.url, responseTime}],
+      [{url, responseTime}],
       {overallSavingsMs}
     );
 

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,42 +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';
 
+/**
+ * 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

@@ -147,7 +147,6 @@ const defaultConfig = {
   audits: [
     'is-on-https',
     'redirects-http',
-    'viewport',
     'metrics/first-contentful-paint',
     'metrics/largest-contentful-paint',
     'metrics/first-meaningful-paint',
@@ -162,7 +161,6 @@ const defaultConfig = {
     'server-response-time',
     'metrics/interactive',
     'user-timings',
-    'critical-request-chains',
     'redirects',
     'image-aspect-ratio',
     'image-size-responsive',
@@ -170,8 +168,6 @@ const defaultConfig = {
     'third-party-cookies',
     'mainthread-work-breakdown',
     'bootup-time',
-    'uses-rel-preconnect',
-    'font-display',
     'diagnostics',
     'network-requests',
     'network-rtt',
@@ -179,15 +175,11 @@ const defaultConfig = {
     'main-thread-tasks',
     'metrics',
     'resource-summary',
-    'third-party-summary',
-    'largest-contentful-paint-element',
-    'lcp-lazy-loaded',
     'layout-shifts',
     'long-tasks',
     'non-composited-animations',
     'unsized-images',
     'valid-source-maps',
-    'prioritize-lcp-image',
     'csp-xss',
     'has-hsts',
     'origin-isolation',
@@ -267,32 +259,20 @@ const defaultConfig = {
     'accessibility/manual/offscreen-content-hidden',
     'accessibility/manual/use-landmarks',
     'accessibility/manual/visual-order-follows-dom',
-    'byte-efficiency/uses-long-cache-ttl',
     'byte-efficiency/total-byte-weight',
     'byte-efficiency/offscreen-images',
-    'byte-efficiency/render-blocking-resources',
     'byte-efficiency/unminified-css',
     'byte-efficiency/unminified-javascript',
     'byte-efficiency/unused-css-rules',
     'byte-efficiency/unused-javascript',
-    'byte-efficiency/modern-image-formats',
-    'byte-efficiency/uses-optimized-images',
-    'byte-efficiency/uses-text-compression',
-    'byte-efficiency/uses-responsive-images',
-    'byte-efficiency/efficient-animated-content',
-    'byte-efficiency/duplicated-javascript',
-    'byte-efficiency/legacy-javascript',
-    'byte-efficiency/uses-responsive-images-snapshot',
     'dobetterweb/doctype',
     'dobetterweb/charset',
-    'dobetterweb/dom-size',
     'dobetterweb/geolocation-on-start',
     'dobetterweb/inspector-issues',
     'dobetterweb/no-document-write',
     'dobetterweb/js-libraries',
     'dobetterweb/notification-on-start',
     'dobetterweb/paste-preventing-inputs',
-    'dobetterweb/uses-http2',
     'dobetterweb/uses-passive-event-listeners',
     'seo/meta-description',
     'seo/http-status-code',
@@ -303,7 +283,6 @@ const defaultConfig = {
     'seo/hreflang',
     'seo/canonical',
     'seo/manual/structured-data',
-    'work-during-interaction',
     'bf-cache',
     'insights/cache-insight',
     'insights/cls-culprits-insight',
@@ -407,67 +386,43 @@ const defaultConfig = {
         {id: 'interaction-to-next-paint', weight: 0, group: 'metrics', acronym: 'INP'},
 
         // Insight audits.
-        {id: 'cache-insight', weight: 0, group: 'hidden'},
-        {id: 'cls-culprits-insight', weight: 0, group: 'hidden'},
-        {id: 'document-latency-insight', weight: 0, group: 'hidden'},
-        {id: 'dom-size-insight', weight: 0, group: 'hidden'},
-        {id: 'duplicated-javascript-insight', weight: 0, group: 'hidden'},
-        {id: 'font-display-insight', weight: 0, group: 'hidden'},
-        {id: 'forced-reflow-insight', weight: 0, group: 'hidden'},
-        {id: 'image-delivery-insight', weight: 0, group: 'hidden'},
-        {id: 'inp-breakdown-insight', weight: 0, group: 'hidden'},
-        {id: 'lcp-breakdown-insight', weight: 0, group: 'hidden'},
-        {id: 'lcp-discovery-insight', weight: 0, group: 'hidden'},
-        {id: 'legacy-javascript-insight', weight: 0, group: 'hidden'},
-        {id: 'modern-http-insight', weight: 0, group: 'hidden'},
-        {id: 'network-dependency-tree-insight', weight: 0, group: 'hidden'},
-        {id: 'render-blocking-insight', weight: 0, group: 'hidden'},
-        {id: 'third-parties-insight', weight: 0, group: 'hidden'},
-        {id: 'viewport-insight', weight: 0, group: 'hidden'},
+        {id: 'cache-insight', weight: 0, group: 'insights'},
+        {id: 'cls-culprits-insight', weight: 0, group: 'insights'},
+        {id: 'document-latency-insight', weight: 0, group: 'insights'},
+        {id: 'dom-size-insight', weight: 0, group: 'insights'},
+        {id: 'duplicated-javascript-insight', weight: 0, group: 'insights'},
+        {id: 'font-display-insight', weight: 0, group: 'insights'},
+        {id: 'forced-reflow-insight', weight: 0, group: 'insights'},
+        {id: 'image-delivery-insight', weight: 0, group: 'insights'},
+        {id: 'inp-breakdown-insight', weight: 0, group: 'insights'},
+        {id: 'lcp-breakdown-insight', weight: 0, group: 'insights'},
+        {id: 'lcp-discovery-insight', weight: 0, group: 'insights'},
+        {id: 'legacy-javascript-insight', weight: 0, group: 'insights'},
+        {id: 'modern-http-insight', weight: 0, group: 'insights'},
+        {id: 'network-dependency-tree-insight', weight: 0, group: 'insights'},
+        {id: 'render-blocking-insight', weight: 0, group: 'insights'},
+        {id: 'third-parties-insight', weight: 0, group: 'insights'},
+        {id: 'viewport-insight', weight: 0, group: 'insights'},
 
         // 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: 'render-blocking-resources', weight: 0, group: 'diagnostics'},
-        {id: 'uses-responsive-images', weight: 0, group: 'diagnostics'},
         {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'},
         {id: 'unused-javascript', weight: 0, group: 'diagnostics'},
-        {id: 'uses-optimized-images', weight: 0, group: 'diagnostics'},
-        {id: 'modern-image-formats', weight: 0, group: 'diagnostics'},
-        {id: 'uses-text-compression', weight: 0, group: 'diagnostics'},
-        {id: 'uses-rel-preconnect', weight: 0, group: 'diagnostics'},
-        {id: 'server-response-time', weight: 0, group: 'diagnostics'},
-        {id: 'redirects', weight: 0, group: 'diagnostics'},
-        {id: 'uses-http2', weight: 0, group: 'diagnostics'},
-        {id: 'efficient-animated-content', weight: 0, group: 'diagnostics'},
-        {id: 'duplicated-javascript', weight: 0, group: 'diagnostics'},
-        {id: 'legacy-javascript', weight: 0, group: 'diagnostics'},
-        {id: 'prioritize-lcp-image', weight: 0, group: 'diagnostics'},
         {id: 'total-byte-weight', weight: 0, group: 'diagnostics'},
-        {id: 'uses-long-cache-ttl', weight: 0, group: 'diagnostics'},
-        {id: 'dom-size', weight: 0, group: 'diagnostics'},
-        {id: 'critical-request-chains', weight: 0, group: 'diagnostics'},
         {id: 'user-timings', weight: 0, group: 'diagnostics'},
         {id: 'bootup-time', weight: 0, group: 'diagnostics'},
         {id: 'mainthread-work-breakdown', weight: 0, group: 'diagnostics'},
-        {id: 'font-display', weight: 0, group: 'diagnostics'},
-        {id: 'third-party-summary', weight: 0, group: 'diagnostics'},
-        {id: 'largest-contentful-paint-element', weight: 0, group: 'diagnostics'},
-        {id: 'lcp-lazy-loaded', weight: 0, group: 'diagnostics'},
-        {id: 'layout-shifts', 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'},
-        {id: 'viewport', weight: 0, group: 'diagnostics'},
-        {id: 'uses-responsive-images-snapshot', weight: 0, group: 'diagnostics'},
-        {id: 'work-during-interaction', weight: 0, group: 'diagnostics'},
         {id: 'bf-cache', weight: 0, group: 'diagnostics'},
 
         // Audits past this point contain useful data but are not displayed with other audits.
@@ -481,6 +436,9 @@ const defaultConfig = {
         {id: 'final-screenshot', weight: 0, group: 'hidden'},
         {id: 'script-treemap-data', weight: 0, group: 'hidden'},
         {id: 'resource-summary', weight: 0, group: 'hidden'},
+        {id: 'redirects', weight: 0, group: 'hidden'},
+        {id: 'server-response-time', weight: 0, group: 'hidden'},
+        {id: 'layout-shifts', weight: 0, group: 'hidden'},
       ],
     },
     'accessibility': {
@@ -610,7 +568,6 @@ const defaultConfig = {
         {id: 'paste-preventing-inputs', weight: 3, group: 'best-practices-ux'},
         {id: 'image-aspect-ratio', weight: 1, group: 'best-practices-ux'},
         {id: 'image-size-responsive', weight: 1, group: 'best-practices-ux'},
-        {id: 'viewport', weight: 1, group: 'best-practices-ux'},
         // Browser Compatibility
         {id: 'doctype', weight: 1, group: 'best-practices-browser-compat'},
         {id: 'charset', weight: 1, group: 'best-practices-browser-compat'},