lighthouse 12.1.0 → 12.2.0

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

@@ -8,23 +8,23 @@ export type LighthouseErrorDefinition = {
     lhrRuntimeError?: boolean | undefined;
 };
 export type SerializedLighthouseError = {
-    sentinel: '__LighthouseErrorSentinel';
+    sentinel: "__LighthouseErrorSentinel";
     code: string;
-    stack?: string | undefined;
+    stack?: string;
     cause?: unknown;
     properties?: {
         [p: string]: string | undefined;
-    } | undefined;
+    };
 };
 export type SerializedBaseError = {
-    sentinel: '__ErrorSentinel';
+    sentinel: "__ErrorSentinel";
     message: string;
     code?: string;
     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.
+ * 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 = {
@@ -80,273 +80,273 @@ export class LighthouseError extends Error {
 }
 export namespace LighthouseError {
     export { ERRORS as errors };
-    export const NO_ERROR: string;
-    export const UNKNOWN_ERROR: string;
+    export let NO_ERROR: string;
+    export let UNKNOWN_ERROR: string;
 }
 export namespace UIStrings {
-    const didntCollectScreenshots: string;
-    const badTraceRecording: string;
-    const noFcp: string;
-    const noLcp: string;
-    const pageLoadTookTooLong: string;
-    const pageLoadFailed: string;
-    const pageLoadFailedWithStatusCode: string;
-    const pageLoadFailedWithDetails: string;
-    const pageLoadFailedInsecure: string;
-    const pageLoadFailedInterstitial: string;
-    const internalChromeError: string;
-    const requestContentTimeout: string;
-    const notHtml: string;
-    const urlInvalid: string;
-    const protocolTimeout: string;
-    const dnsFailure: string;
-    const pageLoadFailedHung: string;
-    const criTimeout: string;
-    const missingRequiredArtifact: string;
-    const erroredRequiredArtifact: string;
-    const oldChromeDoesNotSupportFeature: string;
-    const targetCrashed: string;
+    let didntCollectScreenshots: string;
+    let badTraceRecording: string;
+    let noFcp: string;
+    let noLcp: string;
+    let pageLoadTookTooLong: string;
+    let pageLoadFailed: string;
+    let pageLoadFailedWithStatusCode: string;
+    let pageLoadFailedWithDetails: string;
+    let pageLoadFailedInsecure: string;
+    let pageLoadFailedInterstitial: string;
+    let internalChromeError: string;
+    let requestContentTimeout: string;
+    let notHtml: string;
+    let urlInvalid: string;
+    let protocolTimeout: string;
+    let dnsFailure: string;
+    let pageLoadFailedHung: string;
+    let criTimeout: string;
+    let missingRequiredArtifact: string;
+    let erroredRequiredArtifact: string;
+    let oldChromeDoesNotSupportFeature: string;
+    let targetCrashed: string;
 }
 declare namespace ERRORS {
     namespace NO_SPEEDLINE_FRAMES {
-        export const code: string;
+        export let code: string;
         import message = UIStrings.didntCollectScreenshots;
         export { message };
-        export const lhrRuntimeError: boolean;
+        export let lhrRuntimeError: boolean;
     }
     namespace SPEEDINDEX_OF_ZERO {
-        const code_1: string;
+        let code_1: string;
         export { code_1 as code };
         import message_1 = UIStrings.didntCollectScreenshots;
         export { message_1 as message };
-        const lhrRuntimeError_1: boolean;
+        let lhrRuntimeError_1: boolean;
         export { lhrRuntimeError_1 as lhrRuntimeError };
     }
     namespace NO_SCREENSHOTS {
-        const code_2: string;
+        let code_2: string;
         export { code_2 as code };
         import message_2 = UIStrings.didntCollectScreenshots;
         export { message_2 as message };
-        const lhrRuntimeError_2: boolean;
+        let lhrRuntimeError_2: boolean;
         export { lhrRuntimeError_2 as lhrRuntimeError };
     }
     namespace INVALID_SPEEDLINE {
-        const code_3: string;
+        let code_3: string;
         export { code_3 as code };
         import message_3 = UIStrings.didntCollectScreenshots;
         export { message_3 as message };
-        const lhrRuntimeError_3: boolean;
+        let lhrRuntimeError_3: boolean;
         export { lhrRuntimeError_3 as lhrRuntimeError };
     }
     namespace NO_TRACING_STARTED {
-        const code_4: string;
+        let code_4: string;
         export { code_4 as code };
         import message_4 = UIStrings.badTraceRecording;
         export { message_4 as message };
-        const lhrRuntimeError_4: boolean;
+        let lhrRuntimeError_4: boolean;
         export { lhrRuntimeError_4 as lhrRuntimeError };
     }
     namespace NO_RESOURCE_REQUEST {
-        const code_5: string;
+        let code_5: string;
         export { code_5 as code };
         import message_5 = UIStrings.badTraceRecording;
         export { message_5 as message };
-        const lhrRuntimeError_5: boolean;
+        let lhrRuntimeError_5: boolean;
         export { lhrRuntimeError_5 as lhrRuntimeError };
     }
     namespace NO_NAVSTART {
-        const code_6: string;
+        let code_6: string;
         export { code_6 as code };
         import message_6 = UIStrings.badTraceRecording;
         export { message_6 as message };
-        const lhrRuntimeError_6: boolean;
+        let lhrRuntimeError_6: boolean;
         export { lhrRuntimeError_6 as lhrRuntimeError };
     }
     namespace NO_FCP {
-        const code_7: string;
+        let code_7: string;
         export { code_7 as code };
         import message_7 = UIStrings.noFcp;
         export { message_7 as message };
-        const lhrRuntimeError_7: boolean;
+        let lhrRuntimeError_7: boolean;
         export { lhrRuntimeError_7 as lhrRuntimeError };
     }
     namespace NO_DCL {
-        const code_8: string;
+        let code_8: string;
         export { code_8 as code };
         import message_8 = UIStrings.badTraceRecording;
         export { message_8 as message };
-        const lhrRuntimeError_8: boolean;
+        let lhrRuntimeError_8: boolean;
         export { lhrRuntimeError_8 as lhrRuntimeError };
     }
     namespace NO_FMP {
-        const code_9: string;
+        let code_9: string;
         export { code_9 as code };
         import message_9 = UIStrings.badTraceRecording;
         export { message_9 as message };
     }
     namespace NO_LCP {
-        const code_10: string;
+        let code_10: string;
         export { code_10 as code };
         import message_10 = UIStrings.noLcp;
         export { message_10 as message };
     }
     namespace NO_LCP_ALL_FRAMES {
-        const code_11: string;
+        let code_11: string;
         export { code_11 as code };
         import message_11 = UIStrings.noLcp;
         export { message_11 as message };
     }
     namespace UNSUPPORTED_OLD_CHROME {
-        const code_12: string;
+        let code_12: string;
         export { code_12 as code };
         import message_12 = UIStrings.oldChromeDoesNotSupportFeature;
         export { message_12 as message };
     }
     namespace NO_TTI_CPU_IDLE_PERIOD {
-        const code_13: string;
+        let code_13: string;
         export { code_13 as code };
         import message_13 = UIStrings.pageLoadTookTooLong;
         export { message_13 as message };
     }
     namespace NO_TTI_NETWORK_IDLE_PERIOD {
-        const code_14: string;
+        let code_14: string;
         export { code_14 as code };
         import message_14 = UIStrings.pageLoadTookTooLong;
         export { message_14 as message };
     }
     namespace NO_DOCUMENT_REQUEST {
-        const code_15: string;
+        let code_15: string;
         export { code_15 as code };
         import message_15 = UIStrings.pageLoadFailed;
         export { message_15 as message };
-        const lhrRuntimeError_9: boolean;
+        let lhrRuntimeError_9: boolean;
         export { lhrRuntimeError_9 as lhrRuntimeError };
     }
     namespace FAILED_DOCUMENT_REQUEST {
-        const code_16: string;
+        let code_16: string;
         export { code_16 as code };
         import message_16 = UIStrings.pageLoadFailedWithDetails;
         export { message_16 as message };
-        const lhrRuntimeError_10: boolean;
+        let lhrRuntimeError_10: boolean;
         export { lhrRuntimeError_10 as lhrRuntimeError };
     }
     namespace ERRORED_DOCUMENT_REQUEST {
-        const code_17: string;
+        let code_17: string;
         export { code_17 as code };
         import message_17 = UIStrings.pageLoadFailedWithStatusCode;
         export { message_17 as message };
-        const lhrRuntimeError_11: boolean;
+        let lhrRuntimeError_11: boolean;
         export { lhrRuntimeError_11 as lhrRuntimeError };
     }
     namespace INSECURE_DOCUMENT_REQUEST {
-        const code_18: string;
+        let code_18: string;
         export { code_18 as code };
         import message_18 = UIStrings.pageLoadFailedInsecure;
         export { message_18 as message };
-        const lhrRuntimeError_12: boolean;
+        let lhrRuntimeError_12: boolean;
         export { lhrRuntimeError_12 as lhrRuntimeError };
     }
     namespace CHROME_INTERSTITIAL_ERROR {
-        const code_19: string;
+        let code_19: string;
         export { code_19 as code };
         import message_19 = UIStrings.pageLoadFailedInterstitial;
         export { message_19 as message };
-        const lhrRuntimeError_13: boolean;
+        let lhrRuntimeError_13: boolean;
         export { lhrRuntimeError_13 as lhrRuntimeError };
     }
     namespace PAGE_HUNG {
-        const code_20: string;
+        let code_20: string;
         export { code_20 as code };
         import message_20 = UIStrings.pageLoadFailedHung;
         export { message_20 as message };
-        const lhrRuntimeError_14: boolean;
+        let lhrRuntimeError_14: boolean;
         export { lhrRuntimeError_14 as lhrRuntimeError };
     }
     namespace NOT_HTML {
-        const code_21: string;
+        let code_21: string;
         export { code_21 as code };
         import message_21 = UIStrings.notHtml;
         export { message_21 as message };
-        const lhrRuntimeError_15: boolean;
+        let lhrRuntimeError_15: boolean;
         export { lhrRuntimeError_15 as lhrRuntimeError };
     }
     namespace TRACING_ALREADY_STARTED {
-        const code_22: string;
+        let code_22: string;
         export { code_22 as code };
         import message_22 = UIStrings.internalChromeError;
         export { message_22 as message };
-        export const pattern: RegExp;
-        const lhrRuntimeError_16: boolean;
+        export let pattern: RegExp;
+        let lhrRuntimeError_16: boolean;
         export { lhrRuntimeError_16 as lhrRuntimeError };
     }
     namespace PARSING_PROBLEM {
-        const code_23: string;
+        let code_23: string;
         export { code_23 as code };
         import message_23 = UIStrings.internalChromeError;
         export { message_23 as message };
-        const pattern_1: RegExp;
+        let pattern_1: RegExp;
         export { pattern_1 as pattern };
-        const lhrRuntimeError_17: boolean;
+        let lhrRuntimeError_17: boolean;
         export { lhrRuntimeError_17 as lhrRuntimeError };
     }
     namespace READ_FAILED {
-        const code_24: string;
+        let code_24: string;
         export { code_24 as code };
         import message_24 = UIStrings.internalChromeError;
         export { message_24 as message };
-        const pattern_2: RegExp;
+        let pattern_2: RegExp;
         export { pattern_2 as pattern };
-        const lhrRuntimeError_18: boolean;
+        let lhrRuntimeError_18: boolean;
         export { lhrRuntimeError_18 as lhrRuntimeError };
     }
     namespace INVALID_URL {
-        const code_25: string;
+        let code_25: string;
         export { code_25 as code };
         import message_25 = UIStrings.urlInvalid;
         export { message_25 as message };
     }
     namespace PROTOCOL_TIMEOUT {
-        const code_26: string;
+        let code_26: string;
         export { code_26 as code };
         import message_26 = UIStrings.protocolTimeout;
         export { message_26 as message };
-        const lhrRuntimeError_19: boolean;
+        let lhrRuntimeError_19: boolean;
         export { lhrRuntimeError_19 as lhrRuntimeError };
     }
     namespace DNS_FAILURE {
-        const code_27: string;
+        let code_27: string;
         export { code_27 as code };
         import message_27 = UIStrings.dnsFailure;
         export { message_27 as message };
-        const lhrRuntimeError_20: boolean;
+        let lhrRuntimeError_20: boolean;
         export { lhrRuntimeError_20 as lhrRuntimeError };
     }
     namespace CRI_TIMEOUT {
-        const code_28: string;
+        let code_28: string;
         export { code_28 as code };
         import message_28 = UIStrings.criTimeout;
         export { message_28 as message };
-        const lhrRuntimeError_21: boolean;
+        let lhrRuntimeError_21: boolean;
         export { lhrRuntimeError_21 as lhrRuntimeError };
     }
     namespace MISSING_REQUIRED_ARTIFACT {
-        const code_29: string;
+        let code_29: string;
         export { code_29 as code };
         import message_29 = UIStrings.missingRequiredArtifact;
         export { message_29 as message };
     }
     namespace ERRORED_REQUIRED_ARTIFACT {
-        const code_30: string;
+        let code_30: string;
         export { code_30 as code };
         import message_30 = UIStrings.erroredRequiredArtifact;
         export { message_30 as message };
     }
     namespace TARGET_CRASHED {
-        const code_31: string;
+        let code_31: string;
         export { code_31 as code };
         import message_31 = UIStrings.targetCrashed;
         export { message_31 as message };
-        const lhrRuntimeError_22: boolean;
+        let lhrRuntimeError_22: boolean;
         export { lhrRuntimeError_22 as lhrRuntimeError };
     }
 }

package/core/lib/lighthouse-compatibility.d.ts

@@ -1,4 +1,4 @@
-export type ItemValueType = import('../../types/lhr/audit-details').default.ItemValueType;
+export type ItemValueType = import("../../types/lhr/audit-details").default.ItemValueType;
 /** @typedef {import('../../types/lhr/audit-details').default.ItemValueType} ItemValueType */
 /**
  * Upgrades an lhr object in-place to account for changes in the data structure over major versions.

package/core/lib/manifest-parser.d.ts

@@ -25,7 +25,7 @@ export function parseManifest(string: string, manifestUrl: string, documentUrl:
         start_url: {
             raw: any;
             value: string;
-            warning?: string | undefined;
+            warning?: string;
         };
         display: {
             raw: any;

package/core/lib/minify-devtoolslog.d.ts

@@ -2,5 +2,5 @@
  * @param {LH.DevtoolsLog} log
  * @return {LH.DevtoolsLog}
  */
-export function minifyDevtoolsLog(log: import("..").DevtoolsLog): import("..").DevtoolsLog;
+export function minifyDevtoolsLog(log: LH.DevtoolsLog): LH.DevtoolsLog;
 //# sourceMappingURL=minify-devtoolslog.d.ts.map

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

@@ -6,7 +6,7 @@
  */
 export function getNetworkError(mainRecord: LH.Artifacts.NetworkRequest | undefined, context: {
     warnings: Array<string | LH.IcuMessage>;
-    ignoreStatusCode?: LH.Config.Settings['ignoreStatusCode'];
+    ignoreStatusCode?: LH.Config.Settings["ignoreStatusCode"];
 }): LH.LighthouseError | undefined;
 /**
  * Returns an error if we ended up on the `chrome-error` page and all other requests failed.
@@ -24,7 +24,7 @@ export function getInterstitialError(mainRecord: LH.Artifacts.NetworkRequest | u
  */
 export function getPageLoadError(navigationError: LH.LighthouseError | undefined, context: {
     url: string;
-    ignoreStatusCode?: boolean | undefined;
+    ignoreStatusCode?: LH.Config.Settings["ignoreStatusCode"];
     networkRecords: Array<LH.Artifacts.NetworkRequest>;
     warnings: Array<string | LH.IcuMessage>;
 }): LH.LighthouseError | undefined;
@@ -36,9 +36,7 @@ export function getPageLoadError(navigationError: LH.LighthouseError | undefined
  */
 export function getNonHtmlError(finalRecord: LH.Artifacts.NetworkRequest | undefined): LH.LighthouseError | undefined;
 export namespace UIStrings {
-    const warningXhtml: string;
-    const warningStatusCode: string;
+    let warningXhtml: string;
+    let warningStatusCode: string;
 }
-import { NetworkRequest } from './network-request.js';
-import { LighthouseError } from './lh-error.js';
 //# sourceMappingURL=navigation-error.d.ts.map

package/core/lib/navigation-error.js

@@ -131,7 +131,7 @@ function getNonHtmlError(finalRecord) {
 function getPageLoadError(navigationError, context) {
   const {url, networkRecords} = context;
   /** @type {LH.Artifacts.NetworkRequest|undefined} */
-  let mainRecord = Lantern.Simulation.NetworkAnalyzer.findResourceForUrl(networkRecords, url);
+  let mainRecord = Lantern.Core.NetworkAnalyzer.findResourceForUrl(networkRecords, url);
 
   // If the url doesn't give us a network request, it's possible we landed on a chrome-error:// page
   // In this case, just get the first document request.
@@ -149,7 +149,7 @@ function getPageLoadError(navigationError, context) {
   // MIME Type is only set on the final redirected document request. Use this for the HTML check instead of root.
   let finalRecord;
   if (mainRecord) {
-    finalRecord = Lantern.Simulation.NetworkAnalyzer.resolveRedirects(mainRecord);
+    finalRecord = Lantern.Core.NetworkAnalyzer.resolveRedirects(mainRecord);
   } else {
     // We have no network requests to process, use the navError
     return navigationError;

package/core/lib/network-recorder.js

@@ -253,7 +253,7 @@ class NetworkRecorder extends RequestEventEmitter {
       return record.redirectSource;
     }
 
-    const initiatorURL = Lantern.PageDependencyGraph.getNetworkInitiators(record)[0];
+    const initiatorURL = Lantern.Graph.PageDependencyGraph.getNetworkInitiators(record)[0];
     let candidates = recordsByURL.get(initiatorURL) || [];
     // The (valid) initiator must come before the initiated request.
     candidates = candidates.filter(c => {

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

@@ -49,14 +49,14 @@ export class NetworkRequest {
     static get TYPES(): LH.Util.SelfMap<LH.Crdp.Network.ResourceType>;
     /**
      * @param {NetworkRequest} record
-     * @return {Lantern.NetworkRequest<NetworkRequest>}
+     * @return {Lantern.Types.NetworkRequest<NetworkRequest>}
      */
-    static asLanternNetworkRequest(record: NetworkRequest): Lantern.NetworkRequest<NetworkRequest>;
+    static asLanternNetworkRequest(record: NetworkRequest): Lantern.Types.NetworkRequest<NetworkRequest>;
     /**
-     * @param {NetworkRequest} record
+     * @param {Pick<NetworkRequest, 'protocol'|'parsedURL'>} record
      * @return {boolean}
      */
-    static isNonNetworkRequest(record: NetworkRequest): boolean;
+    static isNonNetworkRequest(record: Pick<NetworkRequest, "protocol" | "parsedURL">): boolean;
     /**
      * Technically there's not alignment on URLs that create "secure connections" vs "secure contexts"
      * https://github.com/GoogleChrome/lighthouse/pull/11766#discussion_r582340683
@@ -206,7 +206,7 @@ export class NetworkRequest {
      * @param {number} timestamp in seconds
      * @param {LH.Crdp.Network.ResponseReceivedEvent['type']=} resourceType
      */
-    _onResponse(response: LH.Crdp.Network.Response, timestamp: number, resourceType?: LH.Crdp.Network.ResponseReceivedEvent['type'] | undefined): void;
+    _onResponse(response: LH.Crdp.Network.Response, timestamp: number, resourceType?: LH.Crdp.Network.ResponseReceivedEvent["type"] | undefined): void;
     responseTimestamp: number | undefined;
     /**
      * Resolve differences between conflicting timing signals. Based on the property setters in DevTools.

package/core/lib/network-request.js

@@ -577,7 +577,7 @@ class NetworkRequest {
 
   /**
    * @param {NetworkRequest} record
-   * @return {Lantern.NetworkRequest<NetworkRequest>}
+   * @return {Lantern.Types.NetworkRequest<NetworkRequest>}
    */
   static asLanternNetworkRequest(record) {
     // In LR, network records are missing connection timing, but we've smuggled it in via headers.
@@ -616,7 +616,7 @@ class NetworkRequest {
   }
 
   /**
-   * @param {NetworkRequest} record
+   * @param {Pick<NetworkRequest, 'protocol'|'parsedURL'>} record
    * @return {boolean}
    */
   static isNonNetworkRequest(record) {

package/core/lib/page-functions.d.ts

@@ -17,7 +17,7 @@ export namespace pageFunctions {
 /**
  * `typed-query-selector`'s CSS selector parser.
  */
-export type ParseSelector<T extends string> = import('typed-query-selector/parser').ParseSelector<T>;
+export type ParseSelector<T extends string> = import("typed-query-selector/parser").ParseSelector<T>;
 /**
  * @fileoverview
  * Helper functions that are passed by `toString()` by Driver to be evaluated in target page.
@@ -55,7 +55,7 @@ declare function wrapRuntimeEvalErrorInBrowser(err?: string | Error | undefined)
  *     Combinators are not supported.
  * @return {Array<ParseSelector<T>>}
  */
-declare function getElementsInDocument<T extends string>(selector?: T | undefined): import("typed-query-selector/parser").ParseSelector<T, Element>[];
+declare function getElementsInDocument<T extends string>(selector?: T | undefined): Array<ParseSelector<T>>;
 /**
  * Gets the opening tag text of the given node.
  * @param {Element|ShadowRoot} element

package/core/lib/script-helpers.d.ts

@@ -42,5 +42,4 @@ export function estimateTransferSize(networkRecord: LH.Artifacts.NetworkRequest
  * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
  */
 export function estimateCompressionRatioForContent(compressionRatioByUrl: Map<string, number>, url: string, artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>): number;
-import { NetworkRequest } from './network-request.js';
 //# sourceMappingURL=script-helpers.d.ts.map

package/core/lib/sentry.d.ts

@@ -3,21 +3,21 @@ export namespace Sentry {
     export { noop as captureMessage };
     export { noop as captureBreadcrumb };
     export { noop as getContext };
-    export const captureException: (error: Error, options: {
-        level?: string | undefined;
+    export let captureException: (error: Error, options: {
+        level?: string;
         tags?: {
             [key: string]: any;
-        } | undefined;
+        };
         extra?: {
             [key: string]: any;
-        } | undefined;
+        };
     }) => Promise<void>;
     export function _shouldSample(): boolean;
 }
-export type Breadcrumb = import('@sentry/node').Breadcrumb;
-export type NodeClient = import('@sentry/node').NodeClient;
-export type NodeOptions = import('@sentry/node').NodeOptions;
-export type Severity = import('@sentry/node').Severity;
+export type Breadcrumb = import("@sentry/node").Breadcrumb;
+export type NodeClient = import("@sentry/node").NodeClient;
+export type NodeOptions = import("@sentry/node").NodeOptions;
+export type Severity = import("@sentry/node").Severity;
 /**
  * When called, replaces noops with actual Sentry implementation.
  * @param {{url: string, flags: LH.CliFlags, config?: LH.Config, environmentData: NodeOptions}} opts

package/core/lib/stack-packs.d.ts

@@ -3,7 +3,7 @@
  * @param {LH.Artifacts['Stacks']|undefined} pageStacks
  * @return {LH.RawIcu<Array<LH.Result.StackPack>>}
  */
-export function getStackPacks(pageStacks: LH.Artifacts['Stacks'] | undefined): LH.RawIcu<Array<LH.Result.StackPack>>;
+export function getStackPacks(pageStacks: LH.Artifacts["Stacks"] | undefined): LH.RawIcu<Array<LH.Result.StackPack>>;
 /**
  * Pairs consisting of a stack pack's ID and the set of stacks needed to be
  * detected in a page to display that pack's advice.

package/core/lib/trace-engine.d.ts

@@ -1,7 +1,7 @@
-export type SyntheticLayoutShift = import('@paulirish/trace_engine').Types.TraceEvents.SyntheticLayoutShift;
+export type SyntheticLayoutShift = import("@paulirish/trace_engine").Types.TraceEvents.SyntheticLayoutShift;
 export type SaneSyntheticLayoutShift = SyntheticLayoutShift & {
     args: {
-        data: NonNullable<SyntheticLayoutShift['args']['data']>;
+        data: NonNullable<SyntheticLayoutShift["args"]["data"]>;
     };
 };
 export const TraceProcessor: typeof TraceEngine.Processor.TraceProcessor;

package/core/lib/tracehouse/cpu-profile-model.d.ts

@@ -3,11 +3,11 @@ export type CpuProfile = {
     pid: number;
     tid: number;
     startTime: number;
-    nodes: Required<LH.TraceCpuProfile>['nodes'];
+    nodes: Required<LH.TraceCpuProfile>["nodes"];
     samples: Array<number>;
     timeDeltas: Array<number>;
 };
-export type ProfilerRange = Required<Required<LH.TraceEvent['args']>['data']>['_syntheticProfilerRange'];
+export type ProfilerRange = Required<Required<LH.TraceEvent["args"]>["data"]>["_syntheticProfilerRange"];
 export type SynthethicEvent = LH.TraceEvent & {
     args: {
         data: {
@@ -15,7 +15,7 @@ export type SynthethicEvent = LH.TraceEvent & {
         };
     };
 };
-export type SynthethicTaskNode = Omit<LH.Artifacts.TaskNode, 'event'> & {
+export type SynthethicTaskNode = Omit<LH.Artifacts.TaskNode, "event"> & {
     event: SynthethicEvent;
     endEvent: SynthethicEvent;
 };
@@ -79,7 +79,7 @@ export class CpuProfileModel {
         startTime: number;
         endTime: number;
     }>, options: {
-        type: 'startTime' | 'endTime';
+        type: "startTime" | "endTime";
         initialIndex: number;
         earliestPossibleTimestamp: number;
         latestPossibleTimestamp: number;
@@ -104,7 +104,7 @@ export class CpuProfileModel {
      */
     static _findEffectiveTimestamp(data: {
         syntheticTask: SynthethicTaskNode;
-        eventType: 'start' | 'end';
+        eventType: "start" | "end";
         allEventsAtTs: {
             naive: Array<SynthethicEvent>;
             refined: Array<SynthethicEvent>;
@@ -149,16 +149,16 @@ export class CpuProfileModel {
         id: number;
         callFrame: {
             functionName: string;
-            url?: string | undefined;
+            url?: string;
         };
-        parent?: number | undefined;
+        parent?: number;
     }>;
     _activeNodeArraysById: Map<number, number[]>;
     /**
      * Initialization function to enable O(1) access to nodes by node ID.
      * @return {Map<number, CpuProfile['nodes'][0]>}
      */
-    _createNodeMap(): Map<number, CpuProfile['nodes'][0]>;
+    _createNodeMap(): Map<number, CpuProfile["nodes"][0]>;
     /**
      * Initialization function to enable O(1) access to the set of active nodes in the stack by node ID.
      * @return {Map<number, Array<number>>}