lighthouse 10.3.0-dev.20230704 → 10.3.0-dev.20230706

package/core/computed/metrics/tbt-utils.js

@@ -6,6 +6,52 @@
 
 const BLOCKING_TIME_THRESHOLD = 50;
 
+/**
+ * For TBT, We only want to consider tasks that fall in our time range
+ * - FCP and TTI for navigation mode
+ * - Trace start and trace end for timespan mode
+ *
+ * FCP is picked as `startTimeMs` because there is little risk of user input happening
+ * before FCP so Long Queuing Qelay regions do not harm user experience. Developers should be
+ * optimizing to reach FCP as fast as possible without having to worry about task lengths.
+ *
+ * TTI is picked as `endTimeMs` because we want a well defined end point for page load.
+ *
+ * @param {{start: number, end: number, duration: number}} event
+ * @param {number} startTimeMs Should be FCP in navigation mode and the trace start time in timespan mode
+ * @param {number} endTimeMs Should be TTI in navigation mode and the trace end time in timespan mode
+ * @param {{start: number, end: number, duration: number}} [topLevelEvent] Leave unset if `event` is top level. Has no effect if `event` has the same duration as `topLevelEvent`.
+ * @return {number}
+ */
+function calculateTbtImpactForEvent(event, startTimeMs, endTimeMs, topLevelEvent) {
+  let threshold = BLOCKING_TIME_THRESHOLD;
+
+  // If a task is not top level, it doesn't make sense to subtract the entire 50ms
+  // blocking threshold from the event.
+  //
+  // e.g. A 80ms top level task with two 40ms children should attribute some blocking
+  // time to the 40ms tasks even though they do not meet the 50ms threshold.
+  //
+  // The solution is to scale the threshold for child events to be considered blocking.
+  if (topLevelEvent) threshold *= (event.duration / topLevelEvent.duration);
+
+  if (event.duration < threshold) return 0;
+  if (event.end < startTimeMs) return 0;
+  if (event.start > endTimeMs) return 0;
+
+  // Perform the clipping and then calculate Blocking Region. So if we have a 150ms task
+  // [0, 150] and `startTimeMs` is at 50ms, we first clip the task to [50, 150], and then
+  // calculate the Blocking Region to be [100, 150]. The rational here is that tasks before
+  // the start time are unimportant, so we care whether the main thread is busy more than
+  // 50ms at a time only after the start time.
+  const clippedStart = Math.max(event.start, startTimeMs);
+  const clippedEnd = Math.min(event.end, endTimeMs);
+  const clippedDuration = clippedEnd - clippedStart;
+  if (clippedDuration < threshold) return 0;
+
+  return clippedDuration - threshold;
+}
+
 /**
  * @param {Array<{start: number, end: number, duration: number}>} topLevelEvents
  * @param {number} startTimeMs
@@ -15,36 +61,9 @@ const BLOCKING_TIME_THRESHOLD = 50;
 function calculateSumOfBlockingTime(topLevelEvents, startTimeMs, endTimeMs) {
   if (endTimeMs <= startTimeMs) return 0;
 
-  const threshold = BLOCKING_TIME_THRESHOLD;
   let sumBlockingTime = 0;
   for (const event of topLevelEvents) {
-    // Early exit for small tasks, which should far outnumber long tasks.
-    if (event.duration < threshold) continue;
-
-    // We only want to consider tasks that fall in our time range (FCP and TTI for navigations).
-    // FCP is picked as the lower bound because there is little risk of user input happening
-    // before FCP so Long Queuing Qelay regions do not harm user experience. Developers should be
-    // optimizing to reach FCP as fast as possible without having to worry about task lengths.
-    if (event.end < startTimeMs) continue;
-
-    // TTI is picked as the upper bound because we want a well defined end point for page load.
-    if (event.start > endTimeMs) continue;
-
-    // We first perform the clipping, and then calculate Blocking Region. So if we have a 150ms
-    // task [0, 150] and FCP happens midway at 50ms, we first clip the task to [50, 150], and then
-    // calculate the Blocking Region to be [100, 150]. The rational here is that tasks before FCP
-    // are unimportant, so we care whether the main thread is busy more than 50ms at a time only
-    // after FCP.
-    const clippedStart = Math.max(event.start, startTimeMs);
-    const clippedEnd = Math.min(event.end, endTimeMs);
-    const clippedDuration = clippedEnd - clippedStart;
-    if (clippedDuration < threshold) continue;
-
-    // The duration of the task beyond 50ms at the beginning is considered the Blocking Region.
-    // Example:
-    //   [              250ms Task                   ]
-    //   | First 50ms |   Blocking Region (200ms)    |
-    sumBlockingTime += clippedDuration - threshold;
+    sumBlockingTime += calculateTbtImpactForEvent(event, startTimeMs, endTimeMs);
   }
 
   return sumBlockingTime;
@@ -53,4 +72,5 @@ function calculateSumOfBlockingTime(topLevelEvents, startTimeMs, endTimeMs) {
 export {
   BLOCKING_TIME_THRESHOLD,
   calculateSumOfBlockingTime,
+  calculateTbtImpactForEvent,
 };

package/core/computed/metrics/total-blocking-time.js

@@ -60,7 +60,7 @@ class TotalBlockingTime extends ComputedMetric {
         timing: calculateSumOfBlockingTime(
           events,
           0,
-          data.processedTrace.timestamps.traceEnd
+          data.processedTrace.timings.traceEnd
         ),
       };
     }

package/core/computed/tbt-impact-tasks.d.ts

@@ -0,0 +1,54 @@
+export { TBTImpactTasksComputed as TBTImpactTasks };
+export type TBTImpactTask = LH.Artifacts.TaskNode & {
+    tbtImpact: number;
+    selfTbtImpact: number;
+};
+declare const TBTImpactTasksComputed: typeof TBTImpactTasks & {
+    request: (dependencies: import("../index.js").Artifacts.MetricComputationDataInput, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<TBTImpactTask[]>;
+};
+/** @typedef {LH.Artifacts.TaskNode & {tbtImpact: number, selfTbtImpact: number}} TBTImpactTask */
+declare class TBTImpactTasks {
+    /**
+     * @param {LH.Artifacts.TaskNode} task
+     * @return {LH.Artifacts.TaskNode}
+     */
+    static getTopLevelTask(task: LH.Artifacts.TaskNode): LH.Artifacts.TaskNode;
+    /**
+     * @param {LH.Artifacts.MetricComputationDataInput} metricComputationData
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<{startTimeMs: number, endTimeMs: number}>}
+     */
+    static getTbtBounds(metricComputationData: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<{
+        startTimeMs: number;
+        endTimeMs: number;
+    }>;
+    /**
+     * @param {LH.Artifacts.TaskNode[]} tasks
+     * @param {Map<LH.Artifacts.TaskNode, number>} taskToImpact
+     */
+    static createImpactTasks(tasks: LH.Artifacts.TaskNode[], taskToImpact: Map<LH.Artifacts.TaskNode, number>): TBTImpactTask[];
+    /**
+     * @param {LH.Artifacts.TaskNode[]} tasks
+     * @param {number} startTimeMs
+     * @param {number} endTimeMs
+     * @return {TBTImpactTask[]}
+     */
+    static computeImpactsFromObservedTasks(tasks: LH.Artifacts.TaskNode[], startTimeMs: number, endTimeMs: number): TBTImpactTask[];
+    /**
+     * @param {LH.Artifacts.TaskNode[]} tasks
+     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} tbtNodeTimings
+     * @param {number} startTimeMs
+     * @param {number} endTimeMs
+     * @return {TBTImpactTask[]}
+     */
+    static computeImpactsFromLantern(tasks: LH.Artifacts.TaskNode[], tbtNodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], startTimeMs: number, endTimeMs: number): TBTImpactTask[];
+    /**
+     * @param {LH.Artifacts.MetricComputationDataInput} metricComputationData
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<TBTImpactTask[]>}
+     */
+    static compute_(metricComputationData: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<TBTImpactTask[]>;
+}
+//# sourceMappingURL=tbt-impact-tasks.d.ts.map

package/core/computed/tbt-impact-tasks.js

@@ -0,0 +1,221 @@
+/**
+ * @license Copyright 2023 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import {makeComputedArtifact} from './computed-artifact.js';
+import {MainThreadTasks} from './main-thread-tasks.js';
+import {FirstContentfulPaint} from './metrics/first-contentful-paint.js';
+import {Interactive} from './metrics/interactive.js';
+import {TotalBlockingTime} from './metrics/total-blocking-time.js';
+import {ProcessedTrace} from './processed-trace.js';
+import {calculateTbtImpactForEvent} from './metrics/tbt-utils.js';
+
+/** @typedef {LH.Artifacts.TaskNode & {tbtImpact: number, selfTbtImpact: number}} TBTImpactTask */
+
+class TBTImpactTasks {
+  /**
+   * @param {LH.Artifacts.TaskNode} task
+   * @return {LH.Artifacts.TaskNode}
+   */
+  static getTopLevelTask(task) {
+    let topLevelTask = task;
+    while (topLevelTask.parent) {
+      topLevelTask = topLevelTask.parent;
+    }
+    return topLevelTask;
+  }
+
+  /**
+   * @param {LH.Artifacts.MetricComputationDataInput} metricComputationData
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<{startTimeMs: number, endTimeMs: number}>}
+   */
+  static async getTbtBounds(metricComputationData, context) {
+    const processedTrace = await ProcessedTrace.request(metricComputationData.trace, context);
+    if (metricComputationData.gatherContext.gatherMode !== 'navigation') {
+      return {
+        startTimeMs: 0,
+        endTimeMs: processedTrace.timings.traceEnd,
+      };
+    }
+
+    const fcpResult = await FirstContentfulPaint.request(metricComputationData, context);
+    const ttiResult = await Interactive.request(metricComputationData, context);
+
+    let startTimeMs = fcpResult.timing;
+    let endTimeMs = ttiResult.timing;
+
+    // When using lantern, we want to get a pessimistic view of the long tasks.
+    // This means we assume the earliest possible start time and latest possible end time.
+
+    if ('optimisticEstimate' in fcpResult) {
+      startTimeMs = fcpResult.optimisticEstimate.timeInMs;
+    }
+
+    if ('pessimisticEstimate' in ttiResult) {
+      endTimeMs = ttiResult.pessimisticEstimate.timeInMs;
+    }
+
+    return {startTimeMs, endTimeMs};
+  }
+
+  /**
+   * @param {LH.Artifacts.TaskNode[]} tasks
+   * @param {Map<LH.Artifacts.TaskNode, number>} taskToImpact
+   */
+  static createImpactTasks(tasks, taskToImpact) {
+    /** @type {TBTImpactTask[]} */
+    const tbtImpactTasks = [];
+
+    for (const task of tasks) {
+      const tbtImpact = taskToImpact.get(task) || 0;
+      let selfTbtImpact = tbtImpact;
+
+      for (const child of task.children) {
+        const childTbtImpact = taskToImpact.get(child) || 0;
+        selfTbtImpact -= childTbtImpact;
+      }
+
+      tbtImpactTasks.push({
+        ...task,
+        tbtImpact,
+        selfTbtImpact,
+      });
+    }
+
+    return tbtImpactTasks;
+  }
+
+  /**
+   * @param {LH.Artifacts.TaskNode[]} tasks
+   * @param {number} startTimeMs
+   * @param {number} endTimeMs
+   * @return {TBTImpactTask[]}
+   */
+  static computeImpactsFromObservedTasks(tasks, startTimeMs, endTimeMs) {
+    /** @type {Map<LH.Artifacts.TaskNode, number>} */
+    const taskToImpact = new Map();
+
+    for (const task of tasks) {
+      const event = {
+        start: task.startTime,
+        end: task.endTime,
+        duration: task.duration,
+      };
+
+      const topLevelTask = this.getTopLevelTask(task);
+      const topLevelEvent = {
+        start: topLevelTask.startTime,
+        end: topLevelTask.endTime,
+        duration: topLevelTask.duration,
+      };
+
+      const tbtImpact = calculateTbtImpactForEvent(event, startTimeMs, endTimeMs, topLevelEvent);
+
+      taskToImpact.set(task, tbtImpact);
+    }
+
+    return this.createImpactTasks(tasks, taskToImpact);
+  }
+
+  /**
+   * @param {LH.Artifacts.TaskNode[]} tasks
+   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} tbtNodeTimings
+   * @param {number} startTimeMs
+   * @param {number} endTimeMs
+   * @return {TBTImpactTask[]}
+   */
+  static computeImpactsFromLantern(tasks, tbtNodeTimings, startTimeMs, endTimeMs) {
+    /** @type {Map<LH.Artifacts.TaskNode, number>} */
+    const taskToImpact = new Map();
+
+    /** @type {Map<LH.Artifacts.TaskNode, {start: number, end: number, duration: number}>} */
+    const topLevelTaskToEvent = new Map();
+
+    /** @type {Map<LH.TraceEvent, LH.Artifacts.TaskNode>} */
+    const traceEventToTask = new Map();
+    for (const task of tasks) {
+      traceEventToTask.set(task.event, task);
+    }
+
+    // Use lantern TBT timings to calculate the TBT impact of top level tasks.
+    for (const [node, timing] of tbtNodeTimings) {
+      if (node.type !== 'cpu') continue;
+
+      const event = {
+        start: timing.startTime,
+        end: timing.endTime,
+        duration: timing.duration,
+      };
+
+      const tbtImpact = calculateTbtImpactForEvent(event, startTimeMs, endTimeMs);
+
+      const task = traceEventToTask.get(node.event);
+      if (!task) continue;
+
+      topLevelTaskToEvent.set(task, event);
+      taskToImpact.set(task, tbtImpact);
+    }
+
+    // Interpolate the TBT impact of remaining tasks using the top level ancestor tasks.
+    // We don't have any lantern estimates for tasks that are not top level, so we need to estimate
+    // the lantern timing based on the task's observed timing relative to it's top level task's observed timing.
+    for (const task of tasks) {
+      if (taskToImpact.has(task)) continue;
+
+      const topLevelTask = this.getTopLevelTask(task);
+
+      const topLevelEvent = topLevelTaskToEvent.get(topLevelTask);
+      if (!topLevelEvent) continue;
+
+      const startRatio = (task.startTime - topLevelTask.startTime) / topLevelTask.duration;
+      const start = startRatio * topLevelEvent.duration + topLevelEvent.start;
+
+      const endRatio = (topLevelTask.endTime - task.endTime) / topLevelTask.duration;
+      const end = topLevelEvent.end - endRatio * topLevelEvent.duration;
+
+      const event = {
+        start,
+        end,
+        duration: end - start,
+      };
+
+      const tbtImpact = calculateTbtImpactForEvent(event, startTimeMs, endTimeMs, topLevelEvent);
+
+      taskToImpact.set(task, tbtImpact);
+    }
+
+    return this.createImpactTasks(tasks, taskToImpact);
+  }
+
+  /**
+   * @param {LH.Artifacts.MetricComputationDataInput} metricComputationData
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<TBTImpactTask[]>}
+   */
+  static async compute_(metricComputationData, context) {
+    const tbtResult = await TotalBlockingTime.request(metricComputationData, context);
+    const tasks = await MainThreadTasks.request(metricComputationData.trace, context);
+
+    const {startTimeMs, endTimeMs} = await this.getTbtBounds(metricComputationData, context);
+
+    if ('pessimisticEstimate' in tbtResult) {
+      return this.computeImpactsFromLantern(
+        tasks,
+        tbtResult.pessimisticEstimate.nodeTimings,
+        startTimeMs,
+        endTimeMs
+      );
+    }
+
+    return this.computeImpactsFromObservedTasks(tasks, startTimeMs, endTimeMs);
+  }
+}
+
+const TBTImpactTasksComputed = makeComputedArtifact(
+  TBTImpactTasks,
+  ['trace', 'devtoolsLog', 'URL', 'gatherContext', 'settings', 'simulator']
+);
+export {TBTImpactTasksComputed as TBTImpactTasks};

package/core/config/default-config.js

@@ -260,16 +260,19 @@ const defaultConfig = {
     'accessibility/document-title',
     'accessibility/duplicate-id-active',
     'accessibility/duplicate-id-aria',
+    'accessibility/empty-heading',
     'accessibility/form-field-multiple-labels',
     'accessibility/frame-title',
     'accessibility/heading-order',
     'accessibility/html-has-lang',
     'accessibility/html-lang-valid',
     'accessibility/html-xml-lang-mismatch',
+    'accessibility/identical-links-same-purpose',
     'accessibility/image-alt',
     'accessibility/input-button-name',
     'accessibility/input-image-alt',
     'accessibility/label',
+    'accessibility/landmark-one-main',
     'accessibility/link-name',
     'accessibility/link-in-text-block',
     'accessibility/list',
@@ -280,6 +283,7 @@ const defaultConfig = {
     'accessibility/select-name',
     'accessibility/tabindex',
     'accessibility/table-fake-caption',
+    'accessibility/target-size',
     'accessibility/td-has-header',
     'accessibility/td-headers-attr',
     'accessibility/th-has-data-cells',
@@ -568,6 +572,11 @@ const defaultConfig = {
         {id: 'visual-order-follows-dom', weight: 0},
         {id: 'offscreen-content-hidden', weight: 0},
         {id: 'use-landmarks', weight: 0},
+        // Hidden audits
+        {id: 'empty-heading', weight: 0, group: 'hidden'},
+        {id: 'identical-links-same-purpose', weight: 0, group: 'hidden'},
+        {id: 'landmark-one-main', weight: 0, group: 'hidden'},
+        {id: 'target-size', weight: 0, group: 'hidden'},
       ],
     },
     'best-practices': {

package/core/config/filters.d.ts

@@ -59,25 +59,25 @@ export function filterAuditsByGatherMode(audits: LH.Config.ResolvedConfig['audit
  * Filters a categories object and their auditRefs down to the set that can be computed using
  * only the specified audits.
  *
- * @param {LH.Config.LegacyResolvedConfig['categories']} categories
+ * @param {LH.Config.ResolvedConfig['categories']} categories
  * @param {Array<LH.Config.AuditDefn>} availableAudits
- * @return {LH.Config.LegacyResolvedConfig['categories']}
+ * @return {LH.Config.ResolvedConfig['categories']}
  */
-export function filterCategoriesByAvailableAudits(categories: LH.Config.LegacyResolvedConfig['categories'], availableAudits: Array<LH.Config.AuditDefn>): LH.Config.LegacyResolvedConfig['categories'];
+export function filterCategoriesByAvailableAudits(categories: LH.Config.ResolvedConfig['categories'], availableAudits: Array<LH.Config.AuditDefn>): LH.Config.ResolvedConfig['categories'];
 /**
  * Filters a categories object and their auditRefs down to the specified category ids.
  *
- * @param {LH.Config.LegacyResolvedConfig['categories']} categories
+ * @param {LH.Config.ResolvedConfig['categories']} categories
  * @param {string[] | null | undefined} onlyCategories
- * @return {LH.Config.LegacyResolvedConfig['categories']}
+ * @return {LH.Config.ResolvedConfig['categories']}
  */
-export function filterCategoriesByExplicitFilters(categories: LH.Config.LegacyResolvedConfig['categories'], onlyCategories: string[] | null | undefined): LH.Config.LegacyResolvedConfig['categories'];
+export function filterCategoriesByExplicitFilters(categories: LH.Config.ResolvedConfig['categories'], onlyCategories: string[] | null | undefined): LH.Config.ResolvedConfig['categories'];
 /**
  * Optional `supportedModes` property can explicitly exclude a category even if some audits are available.
  *
- * @param {LH.Config.LegacyResolvedConfig['categories']} categories
+ * @param {LH.Config.ResolvedConfig['categories']} categories
  * @param {LH.Gatherer.GatherMode} mode
- * @return {LH.Config.LegacyResolvedConfig['categories']}
+ * @return {LH.Config.ResolvedConfig['categories']}
  */
-export function filterCategoriesByGatherMode(categories: LH.Config.LegacyResolvedConfig['categories'], mode: LH.Gatherer.GatherMode): LH.Config.LegacyResolvedConfig['categories'];
+export function filterCategoriesByGatherMode(categories: LH.Config.ResolvedConfig['categories'], mode: LH.Gatherer.GatherMode): LH.Config.ResolvedConfig['categories'];
 //# sourceMappingURL=filters.d.ts.map

package/core/config/filters.js

@@ -169,9 +169,9 @@ function filterAuditsByGatherMode(audits, mode) {
 /**
  * Optional `supportedModes` property can explicitly exclude a category even if some audits are available.
  *
- * @param {LH.Config.LegacyResolvedConfig['categories']} categories
+ * @param {LH.Config.ResolvedConfig['categories']} categories
  * @param {LH.Gatherer.GatherMode} mode
- * @return {LH.Config.LegacyResolvedConfig['categories']}
+ * @return {LH.Config.ResolvedConfig['categories']}
  */
 function filterCategoriesByGatherMode(categories, mode) {
   if (!categories) return null;
@@ -186,9 +186,9 @@ function filterCategoriesByGatherMode(categories, mode) {
 /**
  * Filters a categories object and their auditRefs down to the specified category ids.
  *
- * @param {LH.Config.LegacyResolvedConfig['categories']} categories
+ * @param {LH.Config.ResolvedConfig['categories']} categories
  * @param {string[] | null | undefined} onlyCategories
- * @return {LH.Config.LegacyResolvedConfig['categories']}
+ * @return {LH.Config.ResolvedConfig['categories']}
  */
 function filterCategoriesByExplicitFilters(categories, onlyCategories) {
   if (!categories || !onlyCategories) return categories;
@@ -202,7 +202,7 @@ function filterCategoriesByExplicitFilters(categories, onlyCategories) {
  * Logs a warning if any specified onlyCategory is not a known category that can
  * be included.
  *
- * @param {LH.Config.LegacyResolvedConfig['categories']} allCategories
+ * @param {LH.Config.ResolvedConfig['categories']} allCategories
  * @param {string[] | null} onlyCategories
  * @return {void}
  */
@@ -220,9 +220,9 @@ function warnOnUnknownOnlyCategories(allCategories, onlyCategories) {
  * Filters a categories object and their auditRefs down to the set that can be computed using
  * only the specified audits.
  *
- * @param {LH.Config.LegacyResolvedConfig['categories']} categories
+ * @param {LH.Config.ResolvedConfig['categories']} categories
  * @param {Array<LH.Config.AuditDefn>} availableAudits
- * @return {LH.Config.LegacyResolvedConfig['categories']}
+ * @return {LH.Config.ResolvedConfig['categories']}
  */
 function filterCategoriesByAvailableAudits(categories, availableAudits) {
   if (!categories) return categories;

package/core/config/validation.js

@@ -223,6 +223,12 @@ function assertValidSettings(settings) {
       throw new Error(`Screen emulation mobile setting (${settings.screenEmulation.mobile}) does not match formFactor setting (${settings.formFactor}). See https://github.com/GoogleChrome/lighthouse/blob/main/docs/emulation.md`);
     }
   }
+
+  const skippedAndOnlyAuditId =
+    settings.skipAudits?.find(auditId => settings.onlyAudits?.includes(auditId));
+  if (skippedAndOnlyAuditId) {
+    throw new Error(`${skippedAndOnlyAuditId} appears in both skipAudits and onlyAudits`);
+  }
 }
 
 /**
@@ -253,7 +259,13 @@ function assertArtifactTopologicalOrder(navigations) {
 function assertValidConfig(resolvedConfig) {
   const {warnings} = assertValidFRNavigations(resolvedConfig.navigations);
 
+  /** @type {Set<string>} */
+  const artifactIds = new Set();
   for (const artifactDefn of resolvedConfig.artifacts || []) {
+    if (artifactIds.has(artifactDefn.id)) {
+      throw new Error(`Config defined multiple artifacts with id '${artifactDefn.id}'`);
+    }
+    artifactIds.add(artifactDefn.id);
     assertValidFRGatherer(artifactDefn.gatherer);
   }
 

package/core/gather/gatherers/accessibility.js

@@ -48,12 +48,14 @@ async function runA11yChecks() {
       'audio-caption': {enabled: false},
       'blink': {enabled: false},
       'duplicate-id': {enabled: false},
+      'empty-heading': {enabled: true},
       'frame-focusable-content': {enabled: false},
       'frame-title-unique': {enabled: false},
       'heading-order': {enabled: true},
       'html-xml-lang-mismatch': {enabled: true},
-      'identical-links-same-purpose': {enabled: false},
+      'identical-links-same-purpose': {enabled: true},
       'input-button-name': {enabled: true},
+      'landmark-one-main': {enabled: true},
       'link-in-text-block': {enabled: true},
       'marquee': {enabled: false},
       'meta-viewport': {enabled: true},
@@ -67,6 +69,7 @@ async function runA11yChecks() {
       'svg-img-alt': {enabled: false},
       'tabindex': {enabled: true},
       'table-fake-caption': {enabled: true},
+      'target-size': {enabled: true},
       'td-has-header': {enabled: true},
     },
   });

package/core/gather/gatherers/seo/font-size.d.ts

@@ -1,5 +1,4 @@
 export default FontSize;
-export type Driver = typeof import("../../../legacy/gather/driver.js");
 export type NodeFontData = LH.Artifacts.FontSize['analyzedFailingNodesData'][0];
 export type BackendIdsToFontData = Map<number, {
     fontSize: number;

package/core/gather/gatherers/seo/font-size.js

@@ -22,7 +22,6 @@ const MINIMAL_LEGIBLE_FONT_SIZE_PX = 12;
 // limit number of protocol calls to make sure that gatherer doesn't take more than 1-2s
 const MAX_NODES_SOURCE_RULE_FETCHED = 50; // number of nodes to fetch the source font-size rule
 
-/** @typedef {import('../../../legacy/gather/driver.js')} Driver */
 /** @typedef {LH.Artifacts.FontSize['analyzedFailingNodesData'][0]} NodeFontData */
 /** @typedef {Map<number, {fontSize: number, textLength: number}>} BackendIdsToFontData */
 

package/core/gather/gatherers/source-maps.js

@@ -4,6 +4,7 @@
  * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
  */
 
+import SDK from '../../lib/cdt/SDK.js';
 import FRGatherer from '../base-gatherer.js';
 
 /**
@@ -32,7 +33,7 @@ class SourceMaps extends FRGatherer {
     if (response.content === null) {
       throw new Error(`Failed fetching source map (${response.status})`);
     }
-    return JSON.parse(response.content);
+    return SDK.SourceMap.parseSourceMap(response.content);
   }
 
   /**
@@ -41,7 +42,7 @@ class SourceMaps extends FRGatherer {
    */
   parseSourceMapFromDataUrl(sourceMapURL) {
     const buffer = Buffer.from(sourceMapURL.split(',')[1], 'base64');
-    return JSON.parse(buffer.toString());
+    return SDK.SourceMap.parseSourceMap(buffer.toString());
   }
 
   /**

package/core/lib/cdt/SDK.d.ts

@@ -1,2 +1,2 @@
-export const TextSourceMap: typeof import("./generated/SourceMap.js");
+export const SourceMap: typeof import("./generated/SourceMap.js");
 //# sourceMappingURL=SDK.d.ts.map

package/core/lib/cdt/SDK.js

@@ -5,12 +5,12 @@
  */
 
 const SDK = {
-  TextSourceMap: require('./generated/SourceMap.js'),
+  SourceMap: require('./generated/SourceMap.js'),
 };
 
 // Add `lastColumnNumber` to mappings. This will eventually be added to CDT.
 // @ts-expect-error
-SDK.TextSourceMap.prototype.computeLastGeneratedColumns = function() {
+SDK.SourceMap.prototype.computeLastGeneratedColumns = function() {
   const mappings = this.mappings();
   if (mappings.length && mappings[0].lastColumnNumber !== undefined) return;
 

package/core/lib/dependency-graph/simulator/simulator.js

@@ -517,7 +517,9 @@ class Simulator {
 
     const wastedBits = wastedBytes * 8;
     const wastedMs = wastedBits / bitsPerSecond * 1000;
-    return wastedMs;
+
+    // This is an estimate of wasted time, so we won't be more precise than 10ms.
+    return Math.round(wastedMs / 10) * 10;
   }
 
   /** @return {Map<string, Map<Node, CompleteNodeTiming>>} */

package/core/lib/navigation-error.d.ts

@@ -15,12 +15,12 @@ export function getInterstitialError(mainRecord: LH.Artifacts.NetworkRequest | u
  * Returns an error if the page load should be considered failed, e.g. from a
  * main document request failure, a security issue, etc.
  * @param {LH.LighthouseError|undefined} navigationError
- * @param {{url: string, loadFailureMode: LH.Gatherer.PassContext['passConfig']['loadFailureMode'], networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
+ * @param {{url: string, loadFailureMode: LH.Config.SharedPassNavigationJson['loadFailureMode'], networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
  * @return {LH.LighthouseError|undefined}
  */
 export function getPageLoadError(navigationError: LH.LighthouseError | undefined, context: {
     url: string;
-    loadFailureMode: LH.Gatherer.PassContext['passConfig']['loadFailureMode'];
+    loadFailureMode: LH.Config.SharedPassNavigationJson['loadFailureMode'];
     networkRecords: Array<LH.Artifacts.NetworkRequest>;
     warnings: Array<string | LH.IcuMessage>;
 }): LH.LighthouseError | undefined;

package/core/lib/navigation-error.js

@@ -110,7 +110,7 @@ function getNonHtmlError(finalRecord) {
  * Returns an error if the page load should be considered failed, e.g. from a
  * main document request failure, a security issue, etc.
  * @param {LH.LighthouseError|undefined} navigationError
- * @param {{url: string, loadFailureMode: LH.Gatherer.PassContext['passConfig']['loadFailureMode'], networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
+ * @param {{url: string, loadFailureMode: LH.Config.SharedPassNavigationJson['loadFailureMode'], networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
  * @return {LH.LighthouseError|undefined}
  */
 function getPageLoadError(navigationError, context) {