lighthouse 12.3.0 → 12.4.0-dev.20250227

package/core/audits/layout-shifts.js

@@ -29,8 +29,6 @@ const UIStrings = {
   rootCauseFontChanges: 'Web font loaded',
   /** A possible reason why that the layout shift occured. */
   rootCauseInjectedIframe: 'Injected iframe',
-  /** A possible reason why that the layout shift occured. */
-  rootCauseRenderBlockingRequest: 'A late network request adjusted the page layout',
   /** Label shown per-audit to show how many layout shifts are present. The `{# shifts found}` placeholder will be replaced with the number of layout shifts. */
   displayValueShiftsFound: `{shiftCount, plural, =1 {1 layout shift found} other {# layout shifts found}}`,
 };
@@ -49,7 +47,7 @@ class LayoutShifts extends Audit {
       description: str_(UIStrings.description),
       scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
       guidanceLevel: 2,
-      requiredArtifacts: ['traces', 'RootCauses', 'TraceElements'],
+      requiredArtifacts: ['traces', 'TraceElements'],
     };
   }
 
@@ -67,11 +65,21 @@ class LayoutShifts extends Audit {
     const traceElements = artifacts.TraceElements
       .filter(element => element.traceEventType === 'layout-shift');
 
+    /** @type {LH.Artifacts.TraceEngineRootCauses} */
+    const allRootCauses = {
+      layoutShifts: new Map(),
+    };
+    for (const insightSet of traceEngineResult.insights.values()) {
+      for (const [shift, reasons] of insightSet.model.CLSCulprits.shifts) {
+        allRootCauses.layoutShifts.set(shift, reasons);
+      }
+    }
+
     /** @type {Item[]} */
     const items = [];
     const layoutShiftEvents =
       /** @type {import('../lib/trace-engine.js').SaneSyntheticLayoutShift[]} */(
-        clusters.flatMap(c => c.events)
+        clusters.flatMap(c => c.events).filter(e => !!e.args.data)
       );
     const topLayoutShiftEvents = layoutShiftEvents
       .sort((a, b) => b.args.data.weighted_score_delta - a.args.data.weighted_score_delta)
@@ -82,41 +90,30 @@ class LayoutShifts extends Audit {
       const biggestImpactElement = traceElements.find(t => t.nodeId === biggestImpactNodeId);
 
       // Turn root causes into sub-items.
-      const index = layoutShiftEvents.indexOf(event);
-      const rootCauses = artifacts.RootCauses.layoutShifts[index];
+      const rootCauses = allRootCauses.layoutShifts.get(event);
       /** @type {SubItem[]} */
       const subItems = [];
       if (rootCauses) {
-        for (const cause of rootCauses.unsizedMedia) {
+        for (const backendNodeId of rootCauses.unsizedImages) {
           const element = artifacts.TraceElements.find(
-            t => t.traceEventType === 'layout-shift' && t.nodeId === cause.node.backendNodeId);
+            t => t.traceEventType === 'trace-engine' && t.nodeId === backendNodeId);
           subItems.push({
             extra: element ? Audit.makeNodeItem(element.node) : undefined,
             cause: str_(UIStrings.rootCauseUnsizedMedia),
           });
         }
-        for (const cause of rootCauses.fontChanges) {
-          const url = cause.request.args.data.url;
+        for (const request of rootCauses.fontRequests) {
+          const url = request.args.data.url;
           subItems.push({
             extra: {type: 'url', value: url},
             cause: str_(UIStrings.rootCauseFontChanges),
           });
         }
-        for (const cause of rootCauses.iframes) {
-          const element = artifacts.TraceElements.find(
-            t => t.traceEventType === 'layout-shift' && t.nodeId === cause.iframe.backendNodeId);
+        if (rootCauses.iframeIds.length) {
           subItems.push({
-            extra: element ? Audit.makeNodeItem(element.node) : undefined,
             cause: str_(UIStrings.rootCauseInjectedIframe),
           });
         }
-        for (const cause of rootCauses.renderBlockingRequests) {
-          const url = cause.request.args.data.url;
-          subItems.push({
-            extra: {type: 'url', value: url},
-            cause: str_(UIStrings.rootCauseRenderBlockingRequest),
-          });
-        }
       }
 
       items.push({

package/core/audits/mainthread-work-breakdown.js

@@ -16,7 +16,6 @@ import * as i18n from '../lib/i18n/i18n.js';
 import {MainThreadTasks} from '../computed/main-thread-tasks.js';
 import {TotalBlockingTime} from '../computed/metrics/total-blocking-time.js';
 import {Sentry} from '../lib/sentry.js';
-import {Util} from '../../shared/util.js';
 
 const UIStrings = {
   /** Title of a diagnostic audit that provides detail on the main thread work the browser did to load the page. This descriptive title is shown to users when the amount is acceptable and no user action is required. */
@@ -142,7 +141,6 @@ class MainThreadWorkBreakdown extends Audit {
 
     return {
       score,
-      scoreDisplayMode: score >= Util.PASS_THRESHOLD ? Audit.SCORING_MODES.INFORMATIVE : undefined,
       numericValue: totalExecutionTime,
       numericUnit: 'millisecond',
       displayValue: str_(i18n.UIStrings.seconds, {timeInMs: totalExecutionTime}),

package/core/audits/seo/is-crawlable.d.ts

@@ -12,6 +12,7 @@ declare class IsCrawlable extends Audit {
             selector?: string;
             boundingRect?: import("../../../types/lhr/audit-details.js").default.Rect;
             nodeLabel?: string;
+            explanation?: string;
         };
     } | undefined;
     /**

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

@@ -92,7 +92,6 @@ class ServerResponseTime extends Audit {
       numericValue: responseTime,
       numericUnit: 'millisecond',
       score: Number(passed),
-      scoreDisplayMode: passed ? Audit.SCORING_MODES.INFORMATIVE : undefined,
       displayValue,
       details,
       metricSavings: {

package/core/computed/metrics/lantern-metric.js

@@ -39,7 +39,11 @@ async function getComputationDataParamsFromTrace(data, context) {
   const graph = await PageDependencyGraph.request({...data, fromTrace: true}, context);
   const traceEngineResult = await TraceEngineResult.request(data, context);
   const frameId = traceEngineResult.data.Meta.mainFrameId;
-  const navigationId = traceEngineResult.data.Meta.mainFrameNavigations[0].args.data.navigationId;
+  const navigationId = traceEngineResult.data.Meta.mainFrameNavigations[0].args.data?.navigationId;
+  if (!navigationId) {
+    throw new Error(`Lantern metrics could not be calculated due to missing navigation id`);
+  }
+
   const processedNavigation = Lantern.TraceEngineComputationData.createProcessedNavigation(
     traceEngineResult.data, frameId, navigationId);
   const simulator = data.simulator || (await LoadSimulator.request(data, context));

package/core/computed/trace-engine-result.js

@@ -20,15 +20,7 @@ class TraceEngineResult {
    * @return {Promise<LH.Artifacts.TraceEngineResult>}
    */
   static async runTraceEngine(traceEvents) {
-    const traceHandlers = {...TraceEngine.TraceHandlers};
-
-    // @ts-expect-error Temporarily disable this handler
-    // It's not currently used anywhere in trace engine insights or Lighthouse.
-    // TODO: Re-enable this when its memory usage is improved in the trace engine
-    // https://github.com/GoogleChrome/lighthouse/issues/16111
-    delete traceHandlers.Invalidations;
-
-    const processor = new TraceEngine.TraceProcessor(traceHandlers);
+    const processor = new TraceEngine.TraceProcessor(TraceEngine.TraceHandlers);
 
     // eslint-disable-next-line max-len
     await processor.parse(/** @type {import('@paulirish/trace_engine').Types.Events.Event[]} */ (
@@ -44,22 +36,84 @@ class TraceEngineResult {
    * @param {import('@paulirish/trace_engine/models/trace/insights/types.js').TraceInsightSets} insightSets
    */
   static localizeInsights(insightSets) {
+    /**
+     * Execute `cb(traceEngineI18nObject)` on every i18n object, recursively. The cb return
+     * value replaces traceEngineI18nObject.
+     * @param {any} obj
+     * @param {(traceEngineI18nObject: {i18nId: string, values?: {}}) => LH.IcuMessage} cb
+     * @param {Set<object>} seen
+     */
+    function recursiveReplaceLocalizableStrings(obj, cb, seen) {
+      if (seen.has(seen)) {
+        return;
+      }
+
+      seen.add(obj);
+
+      if (obj instanceof Map) {
+        for (const [key, value] of obj) {
+          if (value && typeof value === 'object' && 'i18nId' in value) {
+            obj.set(key, cb(value));
+          } else {
+            recursiveReplaceLocalizableStrings(value, cb, seen);
+          }
+        }
+      } else if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+        Object.keys(obj).forEach(key => {
+          const value = obj[key];
+          if (value && typeof value === 'object' && 'i18nId' in value) {
+            obj[key] = cb(value);
+          } else {
+            recursiveReplaceLocalizableStrings(value, cb, seen);
+          }
+        });
+      } else if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+          const value = obj[i];
+          if (value && typeof value === 'object' && 'i18nId' in value) {
+            obj[i] = cb(value);
+          } else {
+            recursiveReplaceLocalizableStrings(value, cb, seen);
+          }
+        }
+      }
+    }
+
     for (const insightSet of insightSets.values()) {
       for (const [name, model] of Object.entries(insightSet.model)) {
         if (model instanceof Error) {
           continue;
         }
 
+        /** @type {Record<string, string>} */
+        let traceEngineUIStrings;
+        if (name in TraceEngine.Insights.Models) {
+          const nameAsKey = /** @type {keyof typeof TraceEngine.Insights.Models} */ (name);
+          traceEngineUIStrings = TraceEngine.Insights.Models[nameAsKey].UIStrings;
+        } else {
+          throw new Error(`insight missing UIStrings: ${name}`);
+        }
+
         const key = `node_modules/@paulirish/trace_engine/models/trace/insights/${name}.js`;
-        const str_ = i18n.createIcuMessageFn(key, {
-          title: model.title,
-          description: model.description,
-        });
+        const str_ = i18n.createIcuMessageFn(key, traceEngineUIStrings);
+
+        // Pass `{i18nId: string, values?: {}}` through Lighthouse's i18n pipeline.
+        // This is equivalent to if we directly did `str_(UIStrings.whatever, ...)`
+        recursiveReplaceLocalizableStrings(model, (traceEngineI18nObject) => {
+          let values = traceEngineI18nObject.values;
+          if (values) {
+            values = structuredClone(values);
+            for (const [key, value] of Object.entries(values)) {
+              if (value && typeof value === 'object' && '__i18nBytes' in value) {
+                // @ts-expect-error
+                values[key] = value.__i18nBytes;
+                // TODO: use an actual byte formatter. Right now, this shows the exact number of bytes.
+              }
+            }
+          }
 
-        // @ts-expect-error coerce to string, should be fine
-        model.title = str_(model.title);
-        // @ts-expect-error coerce to string, should be fine
-        model.description = str_(model.description);
+          return str_(traceEngineI18nObject.i18nId, values);
+        }, new Set());
       }
     }
   }

package/core/config/default-config.js

@@ -15,6 +15,8 @@ const UIStrings = {
   performanceCategoryTitle: 'Performance',
   /** Title of the speed metrics section of the Performance category. Within this section are various speed metrics which quantify the pageload performance into values presented in seconds and milliseconds. */
   metricGroupTitle: 'Metrics',
+  /** Title of the insights section of the Performance category. Within this section are various insights to give developers tips on how to improve the performance of their page. */
+  insightGroupTitle: 'Insights',
   /** Title of an opportunity sub-section of the Performance category. Within this section are audits with imperative titles that suggest actions the user can take to improve the time of the first initial render of the webpage. */
   firstPaintImprovementsGroupTitle: 'First Paint Improvements',
   /** Description of an opportunity sub-section of the Performance category. Within this section are audits with imperative titles that suggest actions the user can take to improve the time of the first initial render of the webpage. */
@@ -107,7 +109,6 @@ const defaultConfig = {
     // Artifacts which can be depended on come first.
     {id: 'DevtoolsLog', gatherer: 'devtools-log'},
     {id: 'Trace', gatherer: 'trace'},
-    {id: 'RootCauses', gatherer: 'root-causes'},
 
     {id: 'Accessibility', gatherer: 'accessibility'},
     {id: 'AnchorElements', gatherer: 'anchor-elements'},
@@ -194,6 +195,7 @@ const defaultConfig = {
     'csp-xss',
     'has-hsts',
     'origin-isolation',
+    'clickjacking-mitigation',
     'script-treemap-data',
     'accessibility/accesskeys',
     'accessibility/aria-allowed-attr',
@@ -307,11 +309,28 @@ const defaultConfig = {
     'seo/manual/structured-data',
     'work-during-interaction',
     'bf-cache',
+    'insights/cls-culprits-insight',
+    'insights/document-latency-insight',
+    'insights/dom-size-insight',
+    'insights/font-display-insight',
+    'insights/forced-reflow-insight',
+    'insights/image-delivery-insight',
+    'insights/interaction-to-next-paint-insight',
+    'insights/lcp-discovery-insight',
+    'insights/lcp-phases-insight',
+    'insights/long-critical-network-tree-insight',
+    'insights/render-blocking-insight',
+    'insights/slow-css-selector-insight',
+    'insights/third-parties-insight',
+    'insights/viewport-insight',
   ],
   groups: {
     'metrics': {
       title: str_(UIStrings.metricGroupTitle),
     },
+    'insights': {
+      title: str_(UIStrings.insightGroupTitle),
+    },
     'diagnostics': {
       title: str_(UIStrings.diagnosticsGroupTitle),
       description: str_(UIStrings.diagnosticsGroupDescription),
@@ -387,6 +406,22 @@ const defaultConfig = {
         {id: 'speed-index', weight: 10, group: 'metrics', acronym: 'SI'},
         {id: 'interaction-to-next-paint', weight: 0, group: 'metrics', acronym: 'INP'},
 
+        // Insight audits.
+        {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: 'font-display-insight', weight: 0, group: 'insights'},
+        {id: 'forced-reflow-insight', weight: 0, group: 'insights'},
+        {id: 'image-delivery-insight', weight: 0, group: 'insights'},
+        {id: 'interaction-to-next-paint-insight', weight: 0, group: 'insights'},
+        {id: 'lcp-discovery-insight', weight: 0, group: 'insights'},
+        {id: 'lcp-phases-insight', weight: 0, group: 'insights'},
+        {id: 'long-critical-network-tree-insight', weight: 0, group: 'insights'},
+        {id: 'render-blocking-insight', weight: 0, group: 'insights'},
+        {id: 'slow-css-selector-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'},
@@ -545,6 +580,7 @@ const defaultConfig = {
         {id: 'csp-xss', weight: 0, group: 'best-practices-trust-safety'},
         {id: 'has-hsts', weight: 0, group: 'best-practices-trust-safety'},
         {id: 'origin-isolation', weight: 0, group: 'best-practices-trust-safety'},
+        {id: 'clickjacking-mitigation', weight: 0, group: 'best-practices-trust-safety'},
         // User Experience
         {id: 'paste-preventing-inputs', weight: 3, group: 'best-practices-ux'},
         {id: 'image-aspect-ratio', weight: 1, group: 'best-practices-ux'},

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

@@ -76,12 +76,15 @@ class InspectorIssues extends BaseGatherer {
       lowTextContrastIssue: [],
       mixedContentIssue: [],
       navigatorUserAgentIssue: [],
+      partitioningBlobURLIssue: [],
       propertyRuleIssue: [],
       quirksModeIssue: [],
       cookieIssue: [],
+      selectElementAccessibilityIssue: [],
       sharedArrayBufferIssue: [],
       sharedDictionaryIssue: [],
       stylesheetLoadingIssue: [],
+      sriMessageSignatureIssue: [],
       federatedAuthUserInfoRequestIssue: [],
     };
     const keys = /** @type {Array<keyof LH.Artifacts['InspectorIssues']>} */(Object.keys(artifact));

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

@@ -9,6 +9,14 @@ export type TraceElementData = {
     type?: string;
 };
 declare class TraceElements extends BaseGatherer {
+    /**
+     * @param {LH.Artifacts.TraceEngineResult} traceEngineResult
+     * @param {string|undefined} navigationId
+     * @return {Promise<Array<{nodeId: number}>>}
+     */
+    static getTraceEngineElements(traceEngineResult: LH.Artifacts.TraceEngineResult, navigationId: string | undefined): Promise<Array<{
+        nodeId: number;
+    }>>;
     /**
      * We want to a single representative node to represent the shift, so let's pick
      * the one with the largest impact (size x distance moved).
@@ -48,8 +56,8 @@ declare class TraceElements extends BaseGatherer {
         nodeId: number;
         type: string;
     } | undefined>;
-    /** @type {LH.Gatherer.GathererMeta<'Trace'|'RootCauses'>} */
-    meta: LH.Gatherer.GathererMeta<"Trace" | "RootCauses">;
+    /** @type {LH.Gatherer.GathererMeta<'Trace'>} */
+    meta: LH.Gatherer.GathererMeta<"Trace">;
     /** @type {Map<string, string>} */
     animationIdToName: Map<string, string>;
     /** @param {LH.Crdp.Animation.AnimationStartedEvent} args */

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

@@ -23,7 +23,6 @@ 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';
-import RootCauses from './root-causes.js';
 import {TraceEngineResult} from '../../computed/trace-engine-result.js';
 
 /** @typedef {{nodeId: number, animations?: {name?: string, failureReasonsMask?: number, unsupportedProperties?: string[]}[], type?: string}} TraceElementData */
@@ -46,10 +45,10 @@ function getNodeDetailsData() {
 /* c8 ignore stop */
 
 class TraceElements extends BaseGatherer {
-  /** @type {LH.Gatherer.GathererMeta<'Trace'|'RootCauses'>} */
+  /** @type {LH.Gatherer.GathererMeta<'Trace'>} */
   meta = {
     supportedModes: ['timespan', 'navigation'],
-    dependencies: {Trace: Trace.symbol, RootCauses: RootCauses.symbol},
+    dependencies: {Trace: Trace.symbol},
   };
 
   /** @type {Map<string, string>} */
@@ -65,6 +64,87 @@ class TraceElements extends BaseGatherer {
     if (name) this.animationIdToName.set(id, name);
   }
 
+  /**
+   * @param {LH.Artifacts.TraceEngineResult} traceEngineResult
+   * @param {string|undefined} navigationId
+   * @return {Promise<Array<{nodeId: number}>>}
+   */
+  static async getTraceEngineElements(traceEngineResult, navigationId) {
+    // Can only resolve elements for the latest insight set, which should correspond
+    // to the current navigation id (if present). Can't resolve elements for pages
+    // that are gone.
+    const insightSet = [...traceEngineResult.insights.values()].at(-1);
+    if (!insightSet) {
+      return [];
+    }
+
+    if (navigationId) {
+      if (insightSet.navigation?.args.data?.navigationId !== navigationId) {
+        return [];
+      }
+    } else {
+      if (insightSet.navigation) {
+        return [];
+      }
+    }
+
+    /**
+     * Execute `cb(obj, key)` on every object property (non-objects only), recursively.
+     * @param {any} obj
+     * @param {(obj: Record<string, unknown>, key: string) => void} cb
+     * @param {Set<object>} seen
+     */
+    function recursiveObjectEnumerate(obj, cb, seen) {
+      if (seen.has(seen)) {
+        return;
+      }
+
+      seen.add(obj);
+
+      if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+        if (obj instanceof Map) {
+          for (const [key, val] of obj) {
+            if (typeof val === 'object') {
+              recursiveObjectEnumerate(val, cb, seen);
+            } else {
+              cb(val, key);
+            }
+          }
+        } else {
+          Object.keys(obj).forEach(key => {
+            if (typeof obj[key] === 'object') {
+              recursiveObjectEnumerate(obj[key], cb, seen);
+            } else {
+              cb(obj[key], key);
+            }
+          });
+        }
+      } else if (Array.isArray(obj)) {
+        obj.forEach(item => {
+          if (typeof item === 'object' || Array.isArray(item)) {
+            recursiveObjectEnumerate(item, cb, seen);
+          }
+        });
+      }
+    }
+
+    /** @type {number[]} */
+    const nodeIds = [];
+    recursiveObjectEnumerate(insightSet.model, (val, key) => {
+      const keys = ['nodeId', 'node_id'];
+      if (typeof val === 'number' && keys.includes(key)) {
+        nodeIds.push(val);
+      }
+    }, new Set());
+
+    // TODO: would be better if unsizedImages was `Array<{nodeId}>`.
+    for (const shift of insightSet.model.CLSCulprits.shifts.values()) {
+      nodeIds.push(...shift.unsizedImages);
+    }
+
+    return [...new Set(nodeIds)].map(id => ({nodeId: id}));
+  }
+
   /**
    * We want to a single representative node to represent the shift, so let's pick
    * the one with the largest impact (size x distance moved).
@@ -147,14 +227,6 @@ class TraceElements extends BaseGatherer {
           nodeIds.push(biggestImpactedNodeId);
         }
 
-        const index = layoutShiftEvents.indexOf(event);
-        const shiftRootCauses = rootCauses.layoutShifts[index];
-        if (shiftRootCauses) {
-          for (const cause of shiftRootCauses.unsizedMedia) {
-            nodeIds.push(cause.node.backendNodeId);
-          }
-        }
-
         return nodeIds.map(nodeId => ({nodeId}));
       });
   }
@@ -319,7 +391,10 @@ class TraceElements extends BaseGatherer {
 
     const processedTrace = await ProcessedTrace.request(trace, context);
     const {mainThreadEvents} = processedTrace;
+    const navigationId = processedTrace.timeOriginEvt.args.data?.navigationId;
 
+    const traceEngineData = await TraceElements.getTraceEngineElements(
+      traceEngineResult, navigationId);
     const lcpNodeData = await TraceElements.getLcpElement(trace, context);
     const shiftsData = await TraceElements.getTopLayoutShifts(
       trace, traceEngineResult.data, rootCauses, context);
@@ -328,6 +403,7 @@ class TraceElements extends BaseGatherer {
 
     /** @type {Map<string, TraceElementData[]>} */
     const backendNodeDataMap = new Map([
+      ['trace-engine', traceEngineData],
       ['largest-contentful-paint', lcpNodeData ? [lcpNodeData] : []],
       ['layout-shift', shiftsData],
       ['animation', animatedElementData],
@@ -336,6 +412,7 @@ class TraceElements extends BaseGatherer {
 
     /** @type {Map<number, LH.Crdp.Runtime.CallFunctionOnResponse | null>} */
     const callFunctionOnCache = new Map();
+    /** @type {LH.Artifacts.TraceElement[]} */
     const traceElements = [];
     for (const [traceEventType, backendNodeData] of backendNodeDataMap) {
       for (let i = 0; i < backendNodeData.length; i++) {
@@ -348,8 +425,8 @@ class TraceElements extends BaseGatherer {
 
         if (response?.result?.value) {
           traceElements.push({
-            traceEventType,
             ...response.result.value,
+            traceEventType,
             animations: backendNodeData[i].animations,
             nodeId: backendNodeId,
             type: backendNodeData[i].type,

package/core/lib/bf-cache-strings.d.ts

@@ -1,6 +1,6 @@
-/** @type {Record<string, {name: LH.IcuMessage} | undefined>} */
+/** @type {Record<string, {name: LH.IcuMessage|string} | undefined>} */
 export const NotRestoredReasonDescription: Record<string, {
-    name: LH.IcuMessage;
+    name: LH.IcuMessage | string;
 } | undefined>;
 export namespace UIStrings {
     let notMainFrame: string;
@@ -77,7 +77,6 @@ export namespace UIStrings {
     let printing: string;
     let webDatabase: string;
     let pictureInPicture: string;
-    let portal: string;
     let speechRecognizer: string;
     let idleManager: string;
     let paymentManager: string;
@@ -87,6 +86,7 @@ export namespace UIStrings {
     let outstandingNetworkRequestDirectSocket: string;
     let injectedJavascript: string;
     let injectedStyleSheet: string;
+    let contentDiscarded: string;
     let contentSecurityHandler: string;
     let contentWebAuthenticationAPI: string;
     let contentFileChooser: string;
@@ -117,8 +117,11 @@ export namespace UIStrings {
     let errorDocument: string;
     let fencedFramesEmbedder: string;
     let keepaliveRequest: string;
-    let authorizationHeader: string;
+    let jsNetworkRequestReceivedCacheControlNoStoreResource: string;
     let indexedDBEvent: string;
     let cookieDisabled: string;
+    let webRTCSticky: string;
+    let webTransportSticky: string;
+    let webSocketSticky: string;
 }
 //# sourceMappingURL=bf-cache-strings.d.ts.map