lighthouse 9.5.0-dev.20230118 → 9.5.0-dev.20230119

package/core/gather/driver/environment.d.ts

@@ -0,0 +1,35 @@
+export namespace UIStrings {
+    const warningSlowHostCpu: string;
+}
+/**
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @return {Promise<LH.Crdp.Browser.GetVersionResponse & {milestone: number}>}
+ */
+export function getBrowserVersion(session: LH.Gatherer.FRProtocolSession): Promise<import("devtools-protocol").Protocol.Browser.GetVersionResponse & {
+    milestone: number;
+}>;
+/**
+ * Computes the benchmark index to get a rough estimate of device class.
+ * @param {LH.Gatherer.FRTransitionalDriver['executionContext']} executionContext
+ * @return {Promise<number>}
+ */
+export function getBenchmarkIndex(executionContext: LH.Gatherer.FRTransitionalDriver['executionContext']): Promise<number>;
+/**
+ * Returns a warning if the host device appeared to be underpowered according to BenchmarkIndex.
+ *
+ * @param {{settings: LH.Config.Settings; baseArtifacts: Pick<LH.Artifacts, 'BenchmarkIndex'>}} context
+ * @return {LH.IcuMessage | undefined}
+ */
+export function getSlowHostCpuWarning(context: {
+    settings: LH.Config.Settings;
+    baseArtifacts: Pick<LH.Artifacts, 'BenchmarkIndex'>;
+}): LH.IcuMessage | undefined;
+/**
+ * @param {{settings: LH.Config.Settings, baseArtifacts: Pick<LH.Artifacts, 'BenchmarkIndex'>}} context
+ * @return {Array<LH.IcuMessage>}
+ */
+export function getEnvironmentWarnings(context: {
+    settings: LH.Config.Settings;
+    baseArtifacts: Pick<LH.Artifacts, 'BenchmarkIndex'>;
+}): Array<LH.IcuMessage>;
+//# sourceMappingURL=environment.d.ts.map

package/core/gather/driver/execution-context.d.ts

@@ -0,0 +1,101 @@
+export class ExecutionContext {
+    /**
+     * Prefix every script evaluation with a shadowing of common globals that tend to be ponyfilled
+     * incorrectly by many sites. This allows functions to still refer to `Promise` instead of
+     * Lighthouse-specific backups like `__nativePromise` (injected by `cacheNativesOnNewDocument` above).
+     */
+    static _cachedNativesPreamble: string;
+    /**
+     * Serializes an array of arguments for use in an `eval` string across the protocol.
+     * @param {unknown[]} args
+     * @return {string}
+     */
+    static serializeArguments(args: unknown[]): string;
+    /** @param {LH.Gatherer.FRProtocolSession} session */
+    constructor(session: LH.Gatherer.FRProtocolSession);
+    _session: LH.Gatherer.FRProtocolSession;
+    /** @type {number|undefined} */
+    _executionContextId: number | undefined;
+    /**
+     * Marks how many execution context ids have been created, for purposes of having a unique
+     * value (that doesn't expose the actual execution context id) to
+     * use for __lighthouseExecutionContextUniqueIdentifier.
+     * @type {number}
+     */
+    _executionContextIdentifiersCreated: number;
+    /**
+     * Returns the isolated context ID currently in use.
+     */
+    getContextId(): number | undefined;
+    /**
+     * Clears the remembered context ID. Use this method when we have knowledge that the runtime context
+     * we were using has been destroyed by the browser and is no longer available.
+     */
+    clearContextId(): void;
+    /**
+     * Returns the cached isolated execution context ID or creates a new execution context for the main
+     * frame. The cached execution context is cleared on every gotoURL invocation, so a new one will
+     * always be created on the first call on a new page.
+     * @return {Promise<number>}
+     */
+    _getOrCreateIsolatedContextId(): Promise<number>;
+    /**
+     * Evaluate an expression in the given execution context; an undefined contextId implies the main
+     * page without isolation.
+     * @param {string} expression
+     * @param {number|undefined} contextId
+     * @return {Promise<*>}
+     */
+    _evaluateInContext(expression: string, contextId: number | undefined): Promise<any>;
+    /**
+     * Note: Prefer `evaluate` instead.
+     * Evaluate an expression in the context of the current page. If useIsolation is true, the expression
+     * will be evaluated in a content script that has access to the page's DOM but whose JavaScript state
+     * is completely separate.
+     * Returns a promise that resolves on the expression's value.
+     * @param {string} expression
+     * @param {{useIsolation?: boolean}=} options
+     * @return {Promise<*>}
+     */
+    evaluateAsync(expression: string, options?: {
+        useIsolation?: boolean;
+    } | undefined): Promise<any>;
+    /**
+     * Evaluate a function in the context of the current page.
+     * If `useIsolation` is true, the function will be evaluated in a content script that has
+     * access to the page's DOM but whose JavaScript state is completely separate.
+     * Returns a promise that resolves on a value of `mainFn`'s return type.
+     * @template {unknown[]} T, R
+     * @param {((...args: T) => R)} mainFn The main function to call.
+     * @param {{args: T, useIsolation?: boolean, deps?: Array<Function|string>}} options `args` should
+     *   match the args of `mainFn`, and can be any serializable value. `deps` are functions that must be
+     *   defined for `mainFn` to work.
+     * @return {Promise<Awaited<R>>}
+     */
+    evaluate<T extends unknown[], R>(mainFn: (...args: T) => R, options: {
+        args: T;
+        useIsolation?: boolean | undefined;
+        deps?: (string | Function)[] | undefined;
+    }): Promise<Awaited<R>>;
+    /**
+     * Evaluate a function on every new frame from now on.
+     * @template {unknown[]} T
+     * @param {((...args: T) => void)} mainFn The main function to call.
+     * @param {{args: T, deps?: Array<Function|string>}} options `args` should
+     *   match the args of `mainFn`, and can be any serializable value. `deps` are functions that must be
+     *   defined for `mainFn` to work.
+     * @return {Promise<void>}
+     */
+    evaluateOnNewDocument<T_1 extends unknown[]>(mainFn: (...args: T_1) => void, options: {
+        args: T_1;
+        deps?: (string | Function)[] | undefined;
+    }): Promise<void>;
+    /**
+     * Cache native functions/objects inside window so we are sure polyfills do not overwrite the
+     * native implementations when the page loads.
+     * @return {Promise<void>}
+     */
+    cacheNativesOnNewDocument(): Promise<void>;
+}
+import * as LH from "../../../types/lh.js";
+//# sourceMappingURL=execution-context.d.ts.map

package/core/gather/driver/execution-context.js

@@ -6,6 +6,7 @@
 
 /* global window */
 
+import * as LH from '../../../types/lh.js';
 import {pageFunctions} from '../../lib/page-functions.js';
 
 class ExecutionContext {
@@ -232,13 +233,6 @@ class ExecutionContext {
       window.__nativeFetch = window.fetch;
       window.__ElementMatches = window.Element.prototype.matches;
       window.__HTMLElementBoundingClientRect = window.HTMLElement.prototype.getBoundingClientRect;
-      // Ensure the native `performance.now` is not overwritable.
-      const performance = window.performance;
-      const performanceNow = window.performance.now;
-      Object.defineProperty(performance, 'now', {
-        value: () => performanceNow.call(performance),
-        writable: false,
-      });
       /* c8 ignore stop */
     }, {args: []});
   }

package/core/gather/driver/navigation.d.ts

@@ -0,0 +1,33 @@
+export type NavigationOptions = {
+    waitUntil: Array<'fcp' | 'load' | 'navigated'>;
+} & LH.Config.SharedPassNavigationJson & Partial<Pick<LH.Config.Settings, 'maxWaitForFcp' | 'maxWaitForLoad' | 'debugNavigation'>>;
+/**
+ * Navigates to the given URL, assuming that the page is not already on this URL.
+ * Resolves on the url of the loaded page, taking into account any redirects.
+ * Typical use of this method involves navigating to a neutral page such as `about:blank` in between
+ * navigations.
+ *
+ * @param {LH.Gatherer.FRTransitionalDriver} driver
+ * @param {LH.NavigationRequestor} requestor
+ * @param {NavigationOptions} options
+ * @return {Promise<{requestedUrl: string, mainDocumentUrl: string, warnings: Array<LH.IcuMessage>}>}
+ */
+export function gotoURL(driver: LH.Gatherer.FRTransitionalDriver, requestor: LH.NavigationRequestor, options: NavigationOptions): Promise<{
+    requestedUrl: string;
+    mainDocumentUrl: string;
+    warnings: Array<LH.IcuMessage>;
+}>;
+/**
+ * @param {{timedOut: boolean, requestedUrl: string, mainDocumentUrl: string; }} navigation
+ * @return {Array<LH.IcuMessage>}
+ */
+export function getNavigationWarnings(navigation: {
+    timedOut: boolean;
+    requestedUrl: string;
+    mainDocumentUrl: string;
+}): Array<LH.IcuMessage>;
+export namespace UIStrings {
+    const warningRedirected: string;
+    const warningTimeout: string;
+}
+//# sourceMappingURL=navigation.d.ts.map

package/core/gather/driver/network-monitor.d.ts

@@ -0,0 +1,82 @@
+export type NetworkRecorderEventMap = import('../../lib/network-recorder.js').NetworkRecorderEventMap;
+export type NetworkMonitorEvent_ = 'network-2-idle' | 'network-critical-idle' | 'networkidle' | 'networkbusy' | 'network-critical-busy' | 'network-2-busy';
+export type NetworkMonitorEventMap = Record<NetworkMonitorEvent_, []> & NetworkRecorderEventMap;
+export type NetworkMonitorEvent = keyof NetworkMonitorEventMap;
+export type NetworkMonitorEmitter = LH.Protocol.StrictEventEmitterClass<NetworkMonitorEventMap>;
+declare const NetworkMonitor_base: NetworkMonitorEmitter;
+export class NetworkMonitor extends NetworkMonitor_base {
+    /**
+     * Finds all time periods where the number of inflight requests is less than or equal to the
+     * number of allowed concurrent requests.
+     * @param {Array<LH.Artifacts.NetworkRequest>} requests
+     * @param {number} allowedConcurrentRequests
+     * @param {number=} endTime
+     * @return {Array<{start: number, end: number}>}
+     */
+    static findNetworkQuietPeriods(requests: Array<LH.Artifacts.NetworkRequest>, allowedConcurrentRequests: number, endTime?: number | undefined): Array<{
+        start: number;
+        end: number;
+    }>;
+    /** @param {LH.Gatherer.FRTransitionalDriver['targetManager']} targetManager */
+    constructor(targetManager: LH.Gatherer.FRTransitionalDriver['targetManager']);
+    /** @type {NetworkRecorder|undefined} */
+    _networkRecorder: NetworkRecorder | undefined;
+    /** @type {Array<LH.Crdp.Page.Frame>} */
+    _frameNavigations: Array<LH.Crdp.Page.Frame>;
+    /** @type {LH.Gatherer.FRTransitionalDriver['targetManager']} */
+    _targetManager: LH.Gatherer.FRTransitionalDriver['targetManager'];
+    /** @type {LH.Gatherer.FRProtocolSession} */
+    _session: LH.Gatherer.FRProtocolSession;
+    /** @param {LH.Crdp.Page.FrameNavigatedEvent} event */
+    _onFrameNavigated: (event: LH.Crdp.Page.FrameNavigatedEvent) => number;
+    /** @param {LH.Protocol.RawEventMessage} event */
+    _onProtocolMessage: (event: LH.Protocol.RawEventMessage) => void;
+    /**
+     * @return {Promise<void>}
+     */
+    enable(): Promise<void>;
+    /**
+     * @return {Promise<void>}
+     */
+    disable(): Promise<void>;
+    /** @return {Promise<{requestedUrl?: string, mainDocumentUrl?: string}>} */
+    getNavigationUrls(): Promise<{
+        requestedUrl?: string | undefined;
+        mainDocumentUrl?: string | undefined;
+    }>;
+    /**
+     * @return {Array<NetworkRequest>}
+     */
+    getInflightRequests(): Array<NetworkRequest>;
+    /**
+     * Returns whether the network is completely idle (i.e. there are 0 inflight network requests).
+     */
+    isIdle(): boolean;
+    /**
+     * Returns whether any important resources for the page are in progress.
+     * Above-the-fold images and XHRs should be included.
+     * Tracking pixels, low priority images, and cross frame requests should be excluded.
+     * @return {boolean}
+     */
+    isCriticalIdle(): boolean;
+    /**
+     * Returns whether the network is semi-idle (i.e. there are 2 or fewer inflight network requests).
+     */
+    is2Idle(): boolean;
+    /**
+     * Returns whether the number of currently inflight requests is less than or
+     * equal to the number of allowed concurrent requests.
+     * @param {number} allowedRequests
+     * @param {(request: NetworkRequest) => boolean} [requestFilter]
+     * @return {boolean}
+     */
+    _isActiveIdlePeriod(allowedRequests: number, requestFilter?: ((request: NetworkRequest) => boolean) | undefined): boolean;
+    /**
+     * Emits the appropriate network status event.
+     */
+    _emitNetworkStatus(): void;
+}
+import { NetworkRecorder } from "../../lib/network-recorder.js";
+import { NetworkRequest } from "../../lib/network-request.js";
+export {};
+//# sourceMappingURL=network-monitor.d.ts.map

package/core/gather/driver/network.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Return the body of the response with the given ID. Rejects if getting the
+ * body times out.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {string} requestId
+ * @param {number} [timeout]
+ * @return {Promise<string>}
+ */
+export function fetchResponseBodyFromCache(session: LH.Gatherer.FRProtocolSession, requestId: string, timeout?: number | undefined): Promise<string>;
+//# sourceMappingURL=network.d.ts.map

package/core/gather/driver/prepare.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Prepares a target for observational analysis by setting throttling and network headers/blocked patterns.
+ *
+ * This method assumes `prepareTargetForNavigationMode` or `prepareTargetForTimespanMode` has already been invoked.
+ *
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Config.Settings} settings
+ * @param {{disableThrottling: boolean, blockedUrlPatterns?: string[]}} options
+ */
+export function prepareThrottlingAndNetwork(session: LH.Gatherer.FRProtocolSession, settings: LH.Config.Settings, options: {
+    disableThrottling: boolean;
+    blockedUrlPatterns?: string[];
+}): Promise<void>;
+/**
+ * Prepares a target to be analyzed in timespan mode by enabling protocol domains, emulation, and throttling.
+ *
+ * @param {LH.Gatherer.FRTransitionalDriver} driver
+ * @param {LH.Config.Settings} settings
+ */
+export function prepareTargetForTimespanMode(driver: LH.Gatherer.FRTransitionalDriver, settings: LH.Config.Settings): Promise<void>;
+/**
+ * Prepares a target to be analyzed in navigation mode by enabling protocol domains, emulation, and new document
+ * handlers for global APIs or error handling.
+ *
+ * This method should be used in combination with `prepareTargetForIndividualNavigation` before a specific navigation occurs.
+ *
+ * @param {LH.Gatherer.FRTransitionalDriver} driver
+ * @param {LH.Config.Settings} settings
+ */
+export function prepareTargetForNavigationMode(driver: LH.Gatherer.FRTransitionalDriver, settings: LH.Config.Settings): Promise<void>;
+/**
+ * Prepares a target for a particular navigation by resetting storage and setting network.
+ *
+ * This method assumes `prepareTargetForNavigationMode` has already been invoked.
+ *
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Config.Settings} settings
+ * @param {Pick<LH.Config.NavigationDefn, 'disableThrottling'|'disableStorageReset'|'blockedUrlPatterns'> & {requestor: LH.NavigationRequestor}} navigation
+ * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
+ */
+export function prepareTargetForIndividualNavigation(session: LH.Gatherer.FRProtocolSession, settings: LH.Config.Settings, navigation: Pick<import("../../../types/config.js").default.NavigationDefn, "blockedUrlPatterns" | "disableStorageReset" | "disableThrottling"> & {
+    requestor: LH.NavigationRequestor;
+}): Promise<{
+    warnings: Array<LH.IcuMessage>;
+}>;
+//# sourceMappingURL=prepare.d.ts.map

package/core/gather/driver/service-workers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license Copyright 2021 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.
+ */
+/**
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @return {Promise<LH.Crdp.ServiceWorker.WorkerVersionUpdatedEvent>}
+ */
+export function getServiceWorkerVersions(session: LH.Gatherer.FRProtocolSession): Promise<LH.Crdp.ServiceWorker.WorkerVersionUpdatedEvent>;
+/**
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @return {Promise<LH.Crdp.ServiceWorker.WorkerRegistrationUpdatedEvent>}
+ */
+export function getServiceWorkerRegistrations(session: LH.Gatherer.FRProtocolSession): Promise<LH.Crdp.ServiceWorker.WorkerRegistrationUpdatedEvent>;
+//# sourceMappingURL=service-workers.d.ts.map

package/core/gather/driver/storage.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {string} url
+ * @return {Promise<LH.IcuMessage[]>}
+ */
+export function clearDataForOrigin(session: LH.Gatherer.FRProtocolSession, url: string): Promise<LH.IcuMessage[]>;
+/**
+ * Clear the network cache on disk and in memory.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @return {Promise<LH.IcuMessage[]>}
+ */
+export function clearBrowserCaches(session: LH.Gatherer.FRProtocolSession): Promise<LH.IcuMessage[]>;
+/**
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {string} url
+ * @return {Promise<LH.IcuMessage | undefined>}
+ */
+export function getImportantStorageWarning(session: LH.Gatherer.FRProtocolSession, url: string): Promise<LH.IcuMessage | undefined>;
+export namespace UIStrings {
+    const warningData: string;
+    const warningCacheTimeout: string;
+    const warningOriginDataTimeout: string;
+}
+//# sourceMappingURL=storage.d.ts.map

package/core/gather/driver/target-manager.d.ts

@@ -0,0 +1,61 @@
+export type TargetWithSession = {
+    target: LH.Crdp.Target.TargetInfo;
+    cdpSession: LH.Puppeteer.CDPSession;
+    session: LH.Gatherer.FRProtocolSession;
+    protocolListener: (event: unknown) => void;
+};
+export type ProtocolEventMap = {
+    'protocolevent': [LH.Protocol.RawEventMessage];
+};
+export type ProtocolEventMessageEmitter = LH.Protocol.StrictEventEmitterClass<ProtocolEventMap>;
+declare const TargetManager_base: ProtocolEventMessageEmitter;
+/**
+ * Tracks targets (the page itself, its iframes, their iframes, etc) as they
+ * appear and allows listeners to the flattened protocol events from all targets.
+ */
+export class TargetManager extends TargetManager_base {
+    /** @param {LH.Puppeteer.CDPSession} cdpSession */
+    constructor(cdpSession: LH.Puppeteer.CDPSession);
+    _enabled: boolean;
+    _rootCdpSession: import("../../../types/puppeteer.js").default.CDPSession;
+    /**
+     * A map of target id to target/session information. Used to ensure unique
+     * attached targets.
+     * @type {Map<string, TargetWithSession>}
+     */
+    _targetIdToTargets: Map<string, TargetWithSession>;
+    /**
+     * @param {LH.Puppeteer.CDPSession} cdpSession
+     */
+    _onSessionAttached(cdpSession: LH.Puppeteer.CDPSession): Promise<void>;
+    /**
+     * @param {LH.Crdp.Page.FrameNavigatedEvent} frameNavigatedEvent
+     */
+    _onFrameNavigated(frameNavigatedEvent: LH.Crdp.Page.FrameNavigatedEvent): Promise<void>;
+    /**
+     * @param {string} sessionId
+     * @return {LH.Gatherer.FRProtocolSession}
+     */
+    _findSession(sessionId: string): LH.Gatherer.FRProtocolSession;
+    /**
+     * Returns the root session.
+     * @return {LH.Gatherer.FRProtocolSession}
+     */
+    rootSession(): LH.Gatherer.FRProtocolSession;
+    /**
+     * Returns a listener for all protocol events from session, and augments the
+     * event with the sessionId.
+     * @param {string} sessionId
+     */
+    _getProtocolEventListener(sessionId: string): <EventName extends keyof import("puppeteer-core").ProtocolMapping.Events>(method: EventName, params: import("../../../types/protocol.js").default.RawEventMessageRecord[EventName]["params"]) => void;
+    /**
+     * @return {Promise<void>}
+     */
+    enable(): Promise<void>;
+    /**
+     * @return {Promise<void>}
+     */
+    disable(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=target-manager.d.ts.map

package/core/gather/driver/wait-for-condition.d.ts

@@ -0,0 +1,116 @@
+export type NetworkMonitor = InstanceType<typeof import("./network-monitor.js")['NetworkMonitor']>;
+export type NetworkMonitorEvent = import('./network-monitor.js').NetworkMonitorEvent;
+export type CancellableWait<T = void> = {
+    promise: Promise<T>;
+    cancel: () => void;
+};
+export type WaitOptions = {
+    pauseAfterFcpMs: number;
+    pauseAfterLoadMs: number;
+    networkQuietThresholdMs: number;
+    cpuQuietThresholdMs: number;
+    maxWaitForLoadedMs: number;
+    maxWaitForFcpMs: number | undefined;
+    _waitForTestOverrides?: {
+        waitForFcp: typeof waitForFcp;
+        waitForLoadEvent: typeof waitForLoadEvent;
+        waitForNetworkIdle: typeof waitForNetworkIdle;
+        waitForCPUIdle: typeof waitForCPUIdle;
+    } | undefined;
+};
+/** @typedef {InstanceType<import('./network-monitor.js')['NetworkMonitor']>} NetworkMonitor */
+/** @typedef {import('./network-monitor.js').NetworkMonitorEvent} NetworkMonitorEvent */
+/**
+ * @template [T=void]
+ * @typedef CancellableWait
+ * @prop {Promise<T>} promise
+ * @prop {() => void} cancel
+ */
+/**
+ * @typedef WaitOptions
+ * @prop {number} pauseAfterFcpMs
+ * @prop {number} pauseAfterLoadMs
+ * @prop {number} networkQuietThresholdMs
+ * @prop {number} cpuQuietThresholdMs
+ * @prop {number} maxWaitForLoadedMs
+ * @prop {number|undefined} maxWaitForFcpMs
+ * @prop {{waitForFcp: typeof waitForFcp, waitForLoadEvent: typeof waitForLoadEvent, waitForNetworkIdle: typeof waitForNetworkIdle, waitForCPUIdle: typeof waitForCPUIdle}} [_waitForTestOverrides]
+ */
+/**
+ * Returns a promise that resolves immediately.
+ * Used for placeholder conditions that we don't want to start waiting for just yet, but still want
+ * to satisfy the same interface.
+ * @return {{promise: Promise<void>, cancel: function(): void}}
+ */
+export function waitForNothing(): {
+    promise: Promise<void>;
+    cancel: () => void;
+};
+/**
+ * Returns a promise that resolve when a frame has been navigated.
+ * Used for detecting that our about:blank reset has been completed.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @return {CancellableWait<LH.Crdp.Page.FrameNavigatedEvent>}
+ */
+export function waitForFrameNavigated(session: LH.Gatherer.FRProtocolSession): CancellableWait<LH.Crdp.Page.FrameNavigatedEvent>;
+/**
+ * Returns a promise that resolve when a frame has a FCP.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {number} pauseAfterFcpMs
+ * @param {number} maxWaitForFcpMs
+ * @return {CancellableWait}
+ */
+export function waitForFcp(session: LH.Gatherer.FRProtocolSession, pauseAfterFcpMs: number, maxWaitForFcpMs: number): CancellableWait;
+/**
+ * Return a promise that resolves `pauseAfterLoadMs` after the load event
+ * fires and a method to cancel internal listeners and timeout.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {number} pauseAfterLoadMs
+ * @return {CancellableWait}
+ */
+export function waitForLoadEvent(session: LH.Gatherer.FRProtocolSession, pauseAfterLoadMs: number): CancellableWait;
+/**
+ * Returns a promise that resolves when the network has been idle (after DCL) for
+ * `networkQuietThresholdMs` ms and a method to cancel internal network listeners/timeout.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {NetworkMonitor} networkMonitor
+ * @param {{networkQuietThresholdMs: number, busyEvent: NetworkMonitorEvent, idleEvent: NetworkMonitorEvent, isIdle(recorder: NetworkMonitor): boolean, pretendDCLAlreadyFired?: boolean}} networkQuietOptions
+ * @return {CancellableWait}
+ */
+export function waitForNetworkIdle(session: LH.Gatherer.FRProtocolSession, networkMonitor: NetworkMonitor, networkQuietOptions: {
+    networkQuietThresholdMs: number;
+    busyEvent: NetworkMonitorEvent;
+    idleEvent: NetworkMonitorEvent;
+    isIdle(recorder: NetworkMonitor): boolean;
+    pretendDCLAlreadyFired?: boolean | undefined;
+}): CancellableWait;
+/**
+ * Resolves when there have been no long tasks for at least waitForCPUQuiet ms.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {number} waitForCPUQuiet
+ * @return {CancellableWait}
+ */
+export function waitForCPUIdle(session: LH.Gatherer.FRProtocolSession, waitForCPUQuiet: number): CancellableWait;
+/**
+ * Returns a promise that resolves when:
+ * - All of the following conditions have been met:
+ *    - page has no security issues
+ *    - pauseAfterLoadMs milliseconds have passed since the load event.
+ *    - networkQuietThresholdMs milliseconds have passed since the last network request that exceeded
+ *      2 inflight requests (network-2-quiet has been reached).
+ *    - cpuQuietThresholdMs have passed since the last long task after network-2-quiet.
+ * - maxWaitForLoadedMs milliseconds have passed.
+ * See https://github.com/GoogleChrome/lighthouse/issues/627 for more.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {NetworkMonitor} networkMonitor
+ * @param {WaitOptions} options
+ * @return {Promise<{timedOut: boolean}>}
+ */
+export function waitForFullyLoaded(session: LH.Gatherer.FRProtocolSession, networkMonitor: NetworkMonitor, options: WaitOptions): Promise<{
+    timedOut: boolean;
+}>;
+/**
+ * @param {LH.Gatherer.FRTransitionalDriver} driver
+ */
+export function waitForUserToContinue(driver: LH.Gatherer.FRTransitionalDriver): Promise<void>;
+//# sourceMappingURL=wait-for-condition.d.ts.map

package/core/gather/driver/wait-for-condition.js

@@ -237,7 +237,8 @@ function waitForCPUIdle(session, waitForCPUQuiet) {
   async function checkForQuiet(executionContext, resolve) {
     if (canceled) return;
     const timeSinceLongTask =
-      await executionContext.evaluate(checkTimeSinceLastLongTaskInPage, {args: []});
+      await executionContext.evaluate(
+        checkTimeSinceLastLongTaskInPage, {args: [], useIsolation: true});
     if (canceled) return;
 
     if (typeof timeSinceLongTask === 'number') {
@@ -260,7 +261,7 @@ function waitForCPUIdle(session, waitForCPUQuiet) {
   const executionContext = new ExecutionContext(session);
   /** @type {Promise<void>} */
   const promise = new Promise((resolve, reject) => {
-    executionContext.evaluate(registerPerformanceObserverInPage, {args: []})
+    executionContext.evaluate(registerPerformanceObserverInPage, {args: [], useIsolation: true})
       .then(() => checkForQuiet(executionContext, resolve))
       .catch(reject);
     cancel = () => {

package/core/gather/driver.d.ts

@@ -0,0 +1,30 @@
+/** @implements {LH.Gatherer.FRTransitionalDriver} */
+export class Driver implements LH.Gatherer.FRTransitionalDriver {
+    /**
+     * @param {LH.Puppeteer.Page} page
+     */
+    constructor(page: LH.Puppeteer.Page);
+    _page: import("../../types/puppeteer.js").default.Page;
+    /** @type {TargetManager|undefined} */
+    _targetManager: TargetManager | undefined;
+    /** @type {ExecutionContext|undefined} */
+    _executionContext: ExecutionContext | undefined;
+    /** @type {Fetcher|undefined} */
+    _fetcher: Fetcher | undefined;
+    defaultSession: import("../../types/gatherer.js").default.FRProtocolSession;
+    /** @return {LH.Gatherer.FRTransitionalDriver['executionContext']} */
+    get executionContext(): ExecutionContext;
+    /** @return {Fetcher} */
+    get fetcher(): Fetcher;
+    get targetManager(): any;
+    /** @return {Promise<string>} */
+    url(): Promise<string>;
+    /** @return {Promise<void>} */
+    connect(): Promise<void>;
+    /** @return {Promise<void>} */
+    disconnect(): Promise<void>;
+}
+import { TargetManager } from "./driver/target-manager.js";
+import { ExecutionContext } from "./driver/execution-context.js";
+import { Fetcher } from "./fetcher.js";
+//# sourceMappingURL=driver.d.ts.map

package/core/gather/fetcher.d.ts

@@ -0,0 +1,63 @@
+export type FetchResponse = {
+    content: string | null;
+    status: number | null;
+};
+/**
+ * @fileoverview Fetcher is a utility for making requests to any arbitrary resource,
+ * ignoring normal browser constraints such as CORS.
+ */
+/** @typedef {{content: string|null, status: number|null}} FetchResponse */
+export class Fetcher {
+    /**
+     * @param {LH.Gatherer.FRProtocolSession} session
+     */
+    constructor(session: LH.Gatherer.FRProtocolSession);
+    session: LH.Gatherer.FRProtocolSession;
+    /**
+     * Fetches any resource using the network directly.
+     *
+     * @param {string} url
+     * @param {{timeout: number}=} options timeout is in ms
+     * @return {Promise<FetchResponse>}
+     */
+    fetchResource(url: string, options?: {
+        timeout: number;
+    } | undefined): Promise<FetchResponse>;
+    /**
+     * @param {string} url
+     * @return {Promise<FetchResponse>}
+     */
+    _fetchWithFetchApi(url: string): Promise<FetchResponse>;
+    /**
+     * @param {string} handle
+     * @param {{timeout: number}=} options,
+     * @return {Promise<string>}
+     */
+    _readIOStream(handle: string, options?: {
+        timeout: number;
+    } | undefined): Promise<string>;
+    /**
+     * @param {string} url
+     * @return {Promise<{stream: LH.Crdp.IO.StreamHandle|null, status: number|null}>}
+     */
+    _loadNetworkResource(url: string): Promise<{
+        stream: LH.Crdp.IO.StreamHandle | null;
+        status: number | null;
+    }>;
+    /**
+     * @param {string} url
+     * @param {{timeout: number}} options timeout is in ms
+     * @return {Promise<FetchResponse>}
+     */
+    _fetchResourceOverProtocol(url: string, options: {
+        timeout: number;
+    }): Promise<FetchResponse>;
+    /**
+     * @template T
+     * @param {Promise<T>} promise
+     * @param {number} ms
+     */
+    _wrapWithTimeout<T>(promise: Promise<T>, ms: number): Promise<T>;
+}
+import * as LH from "../../types/lh.js";
+//# sourceMappingURL=fetcher.d.ts.map