lighthouse 10.3.0 → 10.4.0-dev.20230711

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

@@ -236,6 +236,7 @@ const defaultConfig = {
     'accessibility/accesskeys',
     'accessibility/aria-allowed-attr',
     'accessibility/aria-command-name',
+    'accessibility/aria-dialog-name',
     'accessibility/aria-hidden-body',
     'accessibility/aria-hidden-focus',
     'accessibility/aria-input-field-name',
@@ -245,6 +246,7 @@ const defaultConfig = {
     'accessibility/aria-required-children',
     'accessibility/aria-required-parent',
     'accessibility/aria-roles',
+    'accessibility/aria-text',
     'accessibility/aria-toggle-field-name',
     'accessibility/aria-tooltip-name',
     'accessibility/aria-treeitem-name',
@@ -258,24 +260,30 @@ 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',
     'accessibility/listitem',
     'accessibility/meta-refresh',
     'accessibility/meta-viewport',
     'accessibility/object-alt',
+    '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',
@@ -504,6 +512,7 @@ const defaultConfig = {
         {id: 'accesskeys', weight: 3, group: 'a11y-navigation'},
         {id: 'aria-allowed-attr', weight: 10, group: 'a11y-aria'},
         {id: 'aria-command-name', weight: 3, group: 'a11y-aria'},
+        {id: 'aria-dialog-name', weight: 3, group: 'a11y-aria'},
         {id: 'aria-hidden-body', weight: 10, group: 'a11y-aria'},
         {id: 'aria-hidden-focus', weight: 3, group: 'a11y-aria'},
         {id: 'aria-input-field-name', weight: 3, group: 'a11y-aria'},
@@ -513,6 +522,7 @@ const defaultConfig = {
         {id: 'aria-required-children', weight: 10, group: 'a11y-aria'},
         {id: 'aria-required-parent', weight: 10, group: 'a11y-aria'},
         {id: 'aria-roles', weight: 10, group: 'a11y-aria'},
+        {id: 'aria-text', weight: 3, group: 'a11y-aria'},
         {id: 'aria-toggle-field-name', weight: 3, group: 'a11y-aria'},
         {id: 'aria-tooltip-name', weight: 3, group: 'a11y-aria'},
         {id: 'aria-treeitem-name', weight: 3, group: 'a11y-aria'},
@@ -536,12 +546,14 @@ const defaultConfig = {
         {id: 'input-button-name', weight: 10, group: 'a11y-names-labels'},
         {id: 'input-image-alt', weight: 10, group: 'a11y-names-labels'},
         {id: 'label', weight: 10, group: 'a11y-names-labels'},
+        {id: 'link-in-text-block', weight: 3, group: 'a11y-color-contrast'},
         {id: 'link-name', weight: 3, group: 'a11y-names-labels'},
         {id: 'list', weight: 3, group: 'a11y-tables-lists'},
         {id: 'listitem', weight: 3, group: 'a11y-tables-lists'},
         {id: 'meta-refresh', weight: 10, group: 'a11y-best-practices'},
         {id: 'meta-viewport', weight: 10, group: 'a11y-best-practices'},
         {id: 'object-alt', weight: 3, group: 'a11y-names-labels'},
+        {id: 'select-name', weight: 3, group: 'a11y-names-labels'},
         {id: 'tabindex', weight: 3, group: 'a11y-navigation'},
         {id: 'table-fake-caption', weight: 3, group: 'a11y-tables-lists'},
         {id: 'td-has-header', weight: 10, group: 'a11y-tables-lists'},
@@ -560,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/base-gatherer.d.ts

@@ -1,8 +1,6 @@
 export default FRGatherer;
 /**
- * Base class for all gatherers supporting both Fraggle Rock and the legacy flow.
- * Most extending classes should implement the Fraggle Rock API and let this class handle translation.
- * See core/gather/gatherers/gatherer.js for legacy method explanations.
+ * Base class for all gatherers.
  *
  * @implements {LH.Gatherer.GathererInstance}
  * @implements {LH.Gatherer.FRGathererInstance}

package/core/gather/base-gatherer.js

@@ -9,9 +9,7 @@ import * as LH from '../../types/lh.js';
 /* eslint-disable no-unused-vars */
 
 /**
- * Base class for all gatherers supporting both Fraggle Rock and the legacy flow.
- * Most extending classes should implement the Fraggle Rock API and let this class handle translation.
- * See core/gather/gatherers/gatherer.js for legacy method explanations.
+ * Base class for all gatherers.
  *
  * @implements {LH.Gatherer.GathererInstance}
  * @implements {LH.Gatherer.FRGathererInstance}

package/core/gather/gatherers/accessibility.js

@@ -41,18 +41,22 @@ async function runA11yChecks() {
       // Consider http://go/prcpg for expert review of the aXe rules.
       'accesskeys': {enabled: true},
       'area-alt': {enabled: false},
+      'aria-dialog-name': {enabled: true},
       'aria-roledescription': {enabled: false},
       'aria-treeitem-name': {enabled: true},
+      'aria-text': {enabled: true},
       '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},
-      'link-in-text-block': {enabled: false},
+      'landmark-one-main': {enabled: true},
+      'link-in-text-block': {enabled: true},
       'marquee': {enabled: false},
       'meta-viewport': {enabled: true},
       // https://github.com/dequelabs/axe-core/issues/2958
@@ -60,11 +64,12 @@ async function runA11yChecks() {
       'no-autoplay-audio': {enabled: false},
       'role-img-alt': {enabled: false},
       'scrollable-region-focusable': {enabled: false},
-      'select-name': {enabled: false},
+      'select-name': {enabled: true},
       'server-side-image-map': {enabled: false},
       '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/lh-error.d.ts

@@ -23,10 +23,22 @@ export type SerializedBaseError = {
     stack?: string;
     cause?: unknown;
 };
+/**
+ * The {@link ErrorOptions } type wasn't added until es2022 (Node 16), so we recreate it here to support ts targets before es2022.
+ * TODO: Just use `ErrorOptions` if we can't support targets before es2022 in the docs test.
+ */
+export type LHErrorOptions = {
+    cause: unknown;
+};
 /**
  * @typedef {{sentinel: '__LighthouseErrorSentinel', code: string, stack?: string, cause?: unknown, properties?: {[p: string]: string|undefined}}} SerializedLighthouseError
  * @typedef {{sentinel: '__ErrorSentinel', message: string, code?: string, stack?: string, cause?: unknown}} SerializedBaseError
  */
+/**
+ * The {@link ErrorOptions} type wasn't added until es2022 (Node 16), so we recreate it here to support ts targets before es2022.
+ * TODO: Just use `ErrorOptions` if we can't support targets before es2022 in the docs test.
+ * @typedef {{cause: unknown}} LHErrorOptions
+ */
 export class LighthouseError extends Error {
     /**
      * @param {string} method
@@ -59,9 +71,9 @@ export class LighthouseError extends Error {
     /**
      * @param {LighthouseErrorDefinition} errorDefinition
      * @param {Record<string, string|undefined>=} properties
-     * @param {ErrorOptions=} options
+     * @param {LHErrorOptions=} options
      */
-    constructor(errorDefinition: LighthouseErrorDefinition, properties?: Record<string, string | undefined> | undefined, options?: ErrorOptions | undefined);
+    constructor(errorDefinition: LighthouseErrorDefinition, properties?: Record<string, string | undefined> | undefined, options?: LHErrorOptions | undefined);
     code: string;
     friendlyMessage: import("../index.js").IcuMessage;
     lhrRuntimeError: boolean;

package/core/lib/lh-error.js

@@ -111,11 +111,17 @@ const ERROR_SENTINEL = '__ErrorSentinel';
  * @typedef {{sentinel: '__ErrorSentinel', message: string, code?: string, stack?: string, cause?: unknown}} SerializedBaseError
  */
 
+/**
+ * The {@link ErrorOptions} type wasn't added until es2022 (Node 16), so we recreate it here to support ts targets before es2022.
+ * TODO: Just use `ErrorOptions` if we can't support targets before es2022 in the docs test.
+ * @typedef {{cause: unknown}} LHErrorOptions
+ */
+
 class LighthouseError extends Error {
   /**
    * @param {LighthouseErrorDefinition} errorDefinition
    * @param {Record<string, string|undefined>=} properties
-   * @param {ErrorOptions=} options
+   * @param {LHErrorOptions=} options
    */
   constructor(errorDefinition, properties, options) {
     super(errorDefinition.code, options);

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) {

package/core/lib/network-recorder.js

@@ -80,6 +80,7 @@ class NetworkRecorder extends RequestEventEmitter {
       const request = new NetworkRequest();
       request.onRequestWillBeSent(data);
       request.sessionId = event.sessionId;
+      request.sessionTargetType = event.targetType;
       this.onRequestStarted(request);
       log.verbose('network', `request will be sent to ${request.url}`);
       return;

package/core/lib/stack-packs.js

@@ -23,6 +23,10 @@ const stackPacksToInclude = [
     packId: 'wordpress',
     requiredStacks: ['js:wordpress'],
   },
+  {
+    packId: 'wix',
+    requiredStacks: ['js:wix'],
+  },
   {
     packId: 'wp-rocket',
     requiredStacks: ['js:wp-rocket'],