@wdio/lighthouse-service 9.32.0 → 10.0.0-alpha.149

package/build/index.js

@@ -1,16 +1,8 @@
 // src/commands.ts
 import logger3 from "@wdio/logger";
+import { desktopConfig, startFlow } from "lighthouse";
 
 // src/constants.ts
-import InstallableManifest from "lighthouse/lighthouse-core/audits/installable-manifest.js";
-import ServiceWorker from "lighthouse/lighthouse-core/audits/service-worker.js";
-import SplashScreen from "lighthouse/lighthouse-core/audits/splash-screen.js";
-import ThemedOmnibox from "lighthouse/lighthouse-core/audits/themed-omnibox.js";
-import ContentWidth from "lighthouse/lighthouse-core/audits/content-width.js";
-import Viewport from "lighthouse/lighthouse-core/audits/viewport.js";
-import AppleTouchIcon from "lighthouse/lighthouse-core/audits/apple-touch-icon.js";
-import MaskableIcon from "lighthouse/lighthouse-core/audits/maskable-icon.js";
-import { throttling } from "lighthouse/lighthouse-core/config/constants.js";
 var DEFAULT_TRACING_CATEGORIES = [
   // Exclude default categories. We'll be selective to minimize trace size
   "-*",
@@ -35,13 +27,10 @@ var DEFAULT_TRACING_CATEGORIES = [
   "disabled-by-default-devtools.screenshot",
   // This doesn't add its own events, but adds a `stackTrace` property to devtools.timeline events
   "disabled-by-default-devtools.timeline.stack",
-  // Additional categories used by devtools. Not used by Lighthouse, but included to facilitate
+  // Additional categories used by DevTools. Not used by Lighthouse, but included to facilitate
   // loading traces from Lighthouse into the Performance panel.
   "disabled-by-default-devtools.timeline.frame",
   "latencyInfo"
-  // CPU sampling profiler data only enabled for debugging purposes
-  // 'disabled-by-default-v8.cpu_profiler',
-  // 'disabled-by-default-v8.cpu_profiler.hires',
 ];
 var IGNORED_URLS = [
   "data:,",
@@ -52,8 +41,6 @@ var IGNORED_URLS = [
   // all chrome extensions
 ];
 var FRAME_LOAD_START_TIMEOUT = 2e3;
-var TRACING_TIMEOUT = 15e3;
-var MAX_TRACE_WAIT_TIME = 45e3;
 var DEFAULT_NETWORK_THROTTLING_STATE = "online";
 var DEFAULT_FORM_FACTOR = "desktop";
 var UNSUPPORTED_ERROR_MESSAGE = "Can't connect to Chrome DevTools! The @wdio/lighthouse-service currently only supports Chrome and Chromium!\n\nGiven that cloud vendors don't expose access to the Chrome DevTools Protocol this service also usually only works when running tests locally or through a Selenium Grid (https://www.selenium.dev/documentation/grid/) v4 or higher.";
@@ -84,17 +71,15 @@ var NETWORK_STATES = {
   },
   "Regular 3G": {
     offline: false,
-    latency: throttling.mobileRegular3G.requestLatencyMs,
-    // DevTools expects throughput in bytes per second rather than kbps
-    downloadThroughput: Math.floor(throttling.mobileRegular3G.downloadThroughputKbps * 1024 / 8),
-    uploadThroughput: Math.floor(throttling.mobileRegular3G.uploadThroughputKbps * 1024 / 8)
+    latency: 300 * 3.75,
+    downloadThroughput: Math.floor(700 * 1024 / 8),
+    uploadThroughput: Math.floor(700 * 1024 / 8)
   },
   "Good 3G": {
     offline: false,
-    latency: throttling.mobileSlow4G.requestLatencyMs,
-    // DevTools expects throughput in bytes per second rather than kbps
-    downloadThroughput: Math.floor(throttling.mobileSlow4G.downloadThroughputKbps * 1024 / 8),
-    uploadThroughput: Math.floor(throttling.mobileSlow4G.uploadThroughputKbps * 1024 / 8)
+    latency: 150 * 3.75,
+    downloadThroughput: Math.floor(1.6 * 1024 * 1024 / 8),
+    uploadThroughput: Math.floor(750 * 1024 / 8)
   },
   "Regular 4G": {
     offline: false,
@@ -128,25 +113,17 @@ var DEFAULT_THROTTLE_STATE = {
   cacheEnabled: false,
   formFactor: DEFAULT_FORM_FACTOR
 };
-var NETWORK_RECORDER_EVENTS = [
-  "Network.requestWillBeSent",
-  "Network.requestServedFromCache",
-  "Network.responseReceived",
-  "Network.dataReceived",
-  "Network.loadingFinished",
-  "Network.loadingFailed",
-  "Network.resourceChangedPriority"
+var PWA_AUDIT_NAMES = [
+  "isInstallable",
+  "serviceWorker",
+  "splashScreen",
+  "themedOmnibox",
+  "contentWith",
+  "viewport",
+  "appleTouchIcon",
+  "maskableIcon"
 ];
-var PWA_AUDITS = {
-  isInstallable: InstallableManifest,
-  serviceWorker: ServiceWorker,
-  splashScreen: SplashScreen,
-  themedOmnibox: ThemedOmnibox,
-  contentWith: ContentWidth,
-  viewport: Viewport,
-  appleTouchIcon: AppleTouchIcon,
-  maskableIcon: MaskableIcon
-};
+var TRACE_COMMANDS = ["click", "navigateTo", "url"];
 
 // src/handler/network.ts
 var NetworkHandler = class {
@@ -256,35 +233,6 @@ var NetworkHandler = class {
   }
 };
 
-// src/utils.ts
-import Driver from "lighthouse/lighthouse-core/gather/driver.js";
-
-// src/lighthouse/cri.ts
-import CriConnection from "lighthouse/lighthouse-core/gather/connections/cri.js";
-var DEFAULT_HOSTNAME = "localhost";
-var DEFAULT_PORT = "9222";
-var ChromeProtocolPatched = class extends CriConnection {
-  _sessionId;
-  /**
-   * Add constructor for typing safety
-   * @param {number=} port Optional port number. Defaults to 9222;
-   * @param {string=} hostname Optional hostname. Defaults to localhost.
-   * @constructor
-   */
-  constructor(port = DEFAULT_PORT, hostname = DEFAULT_HOSTNAME) {
-    super(port, hostname);
-  }
-  setSessionId(sessionId) {
-    this._sessionId = sessionId;
-  }
-  /**
-   * force every command to be send with the given session id
-   */
-  sendCommand(method, sessionId, ...paramArgs) {
-    return super.sendCommand(method, sessionId || this._sessionId, ...paramArgs);
-  }
-};
-
 // src/utils.ts
 var CUSTOM_COMMANDS = [
   "getMetrics",
@@ -294,7 +242,11 @@ var CUSTOM_COMMANDS = [
   "enablePerformanceAudits",
   "disablePerformanceAudits",
   "getMainThreadWorkBreakdown",
-  "checkPWA"
+  "checkPWA",
+  "getPerformanceScore",
+  "getTraceLogs",
+  "getPageWeight",
+  "endTracing"
 ];
 function setUnsupportedCommand(browser) {
   for (const command of CUSTOM_COMMANDS) {
@@ -314,104 +266,100 @@ function sumByKey(list, key) {
 function isSupportedUrl(url) {
   return IGNORED_URLS.filter((ignoredUrl) => url.startsWith(ignoredUrl)).length === 0;
 }
-async function getLighthouseDriver(session, target) {
-  const connection = session.connection();
-  if (!connection) {
-    throw new Error("Couldn't find a CDP connection");
+function parseTraceBuffer(buffer) {
+  const raw = typeof buffer === "string" ? buffer : Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength).toString("utf8");
+  const parsed = JSON.parse(raw.replace(/^\uFEFF/, ""));
+  if (Array.isArray(parsed)) {
+    return { traceEvents: parsed };
   }
-  const cUrl = new URL(connection.url());
-  const cdpConnection = new ChromeProtocolPatched(cUrl.port, cUrl.hostname);
-  if (!cUrl.pathname.startsWith("/devtools/browser")) {
-    await cdpConnection._connectToSocket({
-      webSocketDebuggerUrl: connection.url(),
-      id: (await target.asPage()).mainFrame()._id
-    });
-    const { sessionId } = await cdpConnection.sendCommand(
-      "Target.attachToTarget",
-      void 0,
-      { targetId: (await target.asPage()).mainFrame()._id, flatten: true }
-    );
-    cdpConnection.setSessionId(sessionId);
-    return new Driver(cdpConnection);
+  if (parsed && typeof parsed === "object") {
+    return parsed;
   }
-  const list = await cdpConnection._runJsonCommand("list");
-  await cdpConnection._connectToSocket(list[0]);
-  return new Driver(cdpConnection);
+  throw new Error("Trace buffer did not contain JSON trace data");
 }
-
-// src/gatherer/devtools.ts
-var DevtoolsGatherer = class {
-  _logs = [];
-  onMessage(msgObj) {
-    this._logs.push(msgObj);
+function isInternalBrowserPage(url) {
+  return url.includes("BiDi-CDP Mapper") || url.startsWith("devtools://") || url.startsWith("chrome-extension://");
+}
+function pageMatchesUrl(pageUrl, currentUrl) {
+  return pageUrl === currentUrl || pageUrl.includes(currentUrl) || currentUrl.includes(pageUrl);
+}
+function resolveAuditablePage(pages, currentUrl) {
+  const candidates = pages.filter((page) => !isInternalBrowserPage(page.url()));
+  if (currentUrl && currentUrl !== "data:,") {
+    const match = candidates.find((page) => pageMatchesUrl(page.url(), currentUrl));
+    if (match) {
+      return match;
+    }
   }
-  /**
-   * retrieve logs and clean cache
-   */
-  getLogs() {
-    return this._logs.splice(0, this._logs.length);
+  return candidates.find((page) => isSupportedUrl(page.url())) ?? candidates.at(-1);
+}
+async function getAuditablePuppeteerPage(puppeteer, currentUrl) {
+  const pages = await puppeteer.pages();
+  const fromPages = resolveAuditablePage(pages, currentUrl);
+  if (fromPages) {
+    return fromPages;
   }
-};
+  if (!puppeteer.waitForTarget) {
+    return void 0;
+  }
+  const target = currentUrl && currentUrl !== "data:," ? await puppeteer.waitForTarget(async (t) => pageMatchesUrl(t.url(), currentUrl) && !isInternalBrowserPage(t.url()) && Boolean(await t.page())) : await puppeteer.waitForTarget(async (t) => (t.type?.() === "page" || Boolean(await t.page())) && !isInternalBrowserPage(t.url()));
+  return await target?.page() ?? void 0;
+}
+var CORE_METRIC_KEYS = [
+  "firstContentfulPaint",
+  "largestContentfulPaint",
+  "speedIndex"
+];
+function metricValue(lhr, auditId, metricKey) {
+  const audits = lhr.audits ?? {};
+  const metrics = audits.metrics?.details?.items?.[0] ?? {};
+  const value = metrics[metricKey] ?? audits[auditId]?.numericValue;
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function hasCorePerformanceMetrics(lhr) {
+  if (!lhr) {
+    return false;
+  }
+  return CORE_METRIC_KEYS.every((key) => {
+    const auditId = key === "firstContentfulPaint" ? "first-contentful-paint" : key === "largestContentfulPaint" ? "largest-contentful-paint" : "speed-index";
+    return metricValue(lhr, auditId, key) !== void 0;
+  });
+}
+function selectLighthouseResult(result) {
+  const steps = result?.steps ?? [];
+  for (let i = steps.length - 1; i >= 0; i--) {
+    if (hasCorePerformanceMetrics(steps[i]?.lhr)) {
+      return steps[i].lhr;
+    }
+  }
+  return steps.at(-1)?.lhr;
+}
+function describeLighthouseResult(lhr) {
+  const url = lhr?.finalDisplayedUrl || lhr?.finalUrl || "unknown";
+  const runtimeError = lhr?.runtimeError ? `${lhr.runtimeError.code ?? "unknown"}: ${lhr.runtimeError.message ?? ""}`.trim() : "none";
+  return `url=${url} runtimeError=${runtimeError}`;
+}
 
 // src/auditor.ts
-import Diagnostics from "lighthouse/lighthouse-core/audits/diagnostics.js";
-import MainThreadWorkBreakdown from "lighthouse/lighthouse-core/audits/mainthread-work-breakdown.js";
-import Metrics from "lighthouse/lighthouse-core/audits/metrics.js";
-import ServerResponseTime from "lighthouse/lighthouse-core/audits/server-response-time.js";
-import CumulativeLayoutShift from "lighthouse/lighthouse-core/audits/metrics/cumulative-layout-shift.js";
-import FirstContentfulPaint from "lighthouse/lighthouse-core/audits/metrics/first-contentful-paint.js";
-import LargestContentfulPaint from "lighthouse/lighthouse-core/audits/metrics/largest-contentful-paint.js";
-import SpeedIndex from "lighthouse/lighthouse-core/audits/metrics/speed-index.js";
-import InteractiveMetric from "lighthouse/lighthouse-core/audits/metrics/interactive.js";
-import TotalBlockingTime from "lighthouse/lighthouse-core/audits/metrics/total-blocking-time.js";
-import ReportScoring from "lighthouse/lighthouse-core/scoring.js";
-import defaultConfig from "lighthouse/lighthouse-core/config/default-config.js";
 import logger from "@wdio/logger";
 var log = logger("@wdio/lighthouse-service:Auditor");
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function roundMetric(value) {
+  const numeric = asNumber(value);
+  return numeric === void 0 ? void 0 : Math.round(numeric);
+}
 var Auditor = class {
-  constructor(_traceLogs, _devtoolsLogs, _formFactor) {
-    this._traceLogs = _traceLogs;
-    this._devtoolsLogs = _devtoolsLogs;
+  constructor(_lhr, _formFactor) {
+    this._lhr = _lhr;
     this._formFactor = _formFactor;
-    if (_traceLogs) {
-      this._url = _traceLogs.pageUrl;
-    }
   }
-  _traceLogs;
-  _devtoolsLogs;
+  _lhr;
   _formFactor;
-  _url;
-  _audit(AUDIT, params = {}) {
-    const auditContext = {
-      options: {
-        ...AUDIT.defaultOptions
-      },
-      settings: {
-        throttlingMethod: "devtools",
-        formFactor: this._formFactor || DEFAULT_FORM_FACTOR
-      },
-      LighthouseRunWarnings: false,
-      computedCache: /* @__PURE__ */ new Map()
-    };
-    try {
-      return AUDIT.audit({
-        traces: { defaultPass: this._traceLogs },
-        devtoolsLogs: { defaultPass: this._devtoolsLogs },
-        TestedAsMobileDevice: true,
-        GatherContext: { gatherMode: "navigation" },
-        ...params
-      }, auditContext);
-    } catch (error) {
-      log.error(error);
-      return {
-        score: 0,
-        error
-      };
-    }
-  }
   /**
-   * an Auditor instance is created for every trace so provide an updateCommands
-   * function to receive the latest performance metrics with the browser instance
+   * an Auditor instance is created for every Lighthouse run so provide an
+   * updateCommands function to receive the latest performance metrics
    */
   updateCommands(browser, customFn) {
     const commands = Object.getOwnPropertyNames(Object.getPrototypeOf(this)).filter(
@@ -420,428 +368,230 @@ var Auditor = class {
     commands.forEach((fnName) => browser.addCommand(fnName, customFn || this[fnName].bind(this)));
   }
   /**
-   * Returns a list with a breakdown of all main thread task and their total duration
+   * Returns a list with a breakdown of all main thread tasks and their total duration
    */
   async getMainThreadWorkBreakdown() {
-    const result = await this._audit(MainThreadWorkBreakdown);
-    return result.details.items.map(
-      ({ group, duration }) => ({ group, duration })
-    );
+    const items = this._lhr?.audits?.["mainthread-work-breakdown"]?.details?.items;
+    if (!Array.isArray(items)) {
+      return [];
+    }
+    return items.map((item) => ({
+      group: String(item.group ?? ""),
+      duration: asNumber(item.duration) ?? 0
+    }));
   }
   /**
    * Get some useful diagnostics about the page load
    */
   async getDiagnostics() {
-    const result = await this._audit(Diagnostics);
-    if (!Object.prototype.hasOwnProperty.call(result, "details")) {
+    const details = this._lhr?.audits?.diagnostics?.details;
+    if (!details || !Array.isArray(details.items) || !details.items[0]) {
       return null;
     }
-    return result.details.items[0];
+    return details.items[0];
   }
   /**
-   * Get most common used performance metrics
+   * Get most commonly used performance metrics
    */
   async getMetrics() {
-    const serverResponseTime = await this._audit(ServerResponseTime, { URL: this._url });
-    const cumulativeLayoutShift = await this._audit(CumulativeLayoutShift);
-    const result = await this._audit(Metrics);
-    const metrics = result.details.items[0] || {};
+    const audits = this._lhr?.audits ?? {};
+    const metrics = audits.metrics?.details?.items?.[0] ?? {};
     return {
-      timeToFirstByte: Math.round(serverResponseTime.numericValue),
-      serverResponseTime: Math.round(serverResponseTime.numericValue),
-      domContentLoaded: metrics.observedDomContentLoaded,
-      firstVisualChange: metrics.observedFirstVisualChange,
-      firstPaint: metrics.observedFirstPaint,
-      firstContentfulPaint: metrics.firstContentfulPaint,
-      firstMeaningfulPaint: metrics.firstMeaningfulPaint,
-      largestContentfulPaint: metrics.largestContentfulPaint,
-      lastVisualChange: metrics.observedLastVisualChange,
-      interactive: metrics.interactive,
-      load: metrics.observedLoad,
-      speedIndex: metrics.speedIndex,
-      totalBlockingTime: metrics.totalBlockingTime,
-      maxPotentialFID: metrics.maxPotentialFID,
-      cumulativeLayoutShift: cumulativeLayoutShift.numericValue
+      timeToFirstByte: roundMetric(audits["server-response-time"]?.numericValue),
+      serverResponseTime: roundMetric(audits["server-response-time"]?.numericValue),
+      domContentLoaded: asNumber(metrics.observedDomContentLoaded),
+      firstVisualChange: asNumber(metrics.observedFirstVisualChange),
+      firstPaint: asNumber(metrics.observedFirstPaint),
+      firstContentfulPaint: asNumber(metrics.firstContentfulPaint ?? audits["first-contentful-paint"]?.numericValue),
+      firstMeaningfulPaint: asNumber(metrics.firstMeaningfulPaint),
+      largestContentfulPaint: asNumber(metrics.largestContentfulPaint ?? audits["largest-contentful-paint"]?.numericValue),
+      lastVisualChange: asNumber(metrics.observedLastVisualChange),
+      interactive: asNumber(metrics.interactive ?? audits.interactive?.numericValue),
+      load: asNumber(metrics.observedLoad),
+      speedIndex: asNumber(metrics.speedIndex ?? audits["speed-index"]?.numericValue),
+      totalBlockingTime: asNumber(metrics.totalBlockingTime ?? audits["total-blocking-time"]?.numericValue),
+      maxPotentialFID: asNumber(metrics.maxPotentialFID ?? audits["max-potential-fid"]?.numericValue),
+      cumulativeLayoutShift: asNumber(
+        audits["cumulative-layout-shift"]?.numericValue ?? metrics.cumulativeLayoutShift
+      ),
+      interactionToNextPaint: asNumber(audits["interaction-to-next-paint"]?.numericValue)
     };
   }
   /**
-   * Returns the Lighthouse Performance Score which is a weighted mean of the following metrics: firstMeaningfulPaint, interactive, speedIndex
+   * Returns the Lighthouse Performance Score, a weighted mean of FCP, SI, LCP, TBT and CLS.
    */
   async getPerformanceScore() {
-    const auditResults = {
-      "speed-index": await this._audit(SpeedIndex),
-      "first-contentful-paint": await this._audit(FirstContentfulPaint),
-      "largest-contentful-paint": await this._audit(LargestContentfulPaint),
-      "cumulative-layout-shift": await this._audit(CumulativeLayoutShift),
-      "total-blocking-time": await this._audit(TotalBlockingTime),
-      interactive: await this._audit(InteractiveMetric)
-    };
-    if (!auditResults.interactive || !auditResults["cumulative-layout-shift"] || !auditResults["first-contentful-paint"] || !auditResults["largest-contentful-paint"] || !auditResults["speed-index"] || !auditResults["total-blocking-time"]) {
-      log.info("One or multiple required metrics couldn't be found, setting performance score to: null");
+    const score = this._lhr?.categories?.performance?.score;
+    if (typeof score !== "number" || Number.isNaN(score)) {
+      log.info("Performance score couldn't be found, setting performance score to: null");
       return null;
     }
-    const scores = defaultConfig.categories.performance.auditRefs.filter((auditRef) => auditRef.weight).map((auditRef) => ({
-      score: auditResults[auditRef.id].score,
-      weight: auditRef.weight
-    }));
-    return ReportScoring.arithmeticMean(scores);
-  }
-  async _auditPWA(params, auditsToBeRun = Object.keys(PWA_AUDITS)) {
-    const audits = await Promise.all(
-      Object.entries(PWA_AUDITS).filter(([name]) => auditsToBeRun.includes(name)).map(
-        async ([name, Audit]) => [name, await this._audit(Audit, params)]
-      )
-    );
-    return {
-      passed: !audits.find(([, result]) => result.score < 1),
-      details: audits.reduce((details, [name, result]) => {
-        details[name] = result;
-        return details;
-      }, {})
-    };
+    return score;
   }
 };
 
-// src/gatherer/pwa.ts
-import FRGatherer from "lighthouse/lighthouse-core/fraggle-rock/gather/session.js";
-import pageFunctions from "lighthouse/lighthouse-core/lib/page-functions.js";
-import NetworkRecorder from "lighthouse/lighthouse-core/lib/network-recorder.js";
-import InstallabilityErrors from "lighthouse/lighthouse-core/gather/gatherers/installability-errors.js";
-import WebAppManifest from "lighthouse/lighthouse-core/gather/gatherers/web-app-manifest.js";
-import LinkElements from "lighthouse/lighthouse-core/gather/gatherers/link-elements.js";
-import ViewportDimensions from "lighthouse/lighthouse-core/gather/gatherers/viewport-dimensions.js";
-import serviceWorkers from "lighthouse/lighthouse-core/gather/driver/service-workers.js";
-
-// src/scripts/collectMetaElements.ts
-function collectMetaElements() {
-  const selector = "head meta";
-  const realMatchesFn = window.Element.prototype.matches;
-  const metas = [];
-  const _findAllElements = (nodes) => {
-    for (let i = 0, el; el = nodes[i]; ++i) {
-      if (!selector || realMatchesFn.call(el, selector)) {
-        metas.push(el);
-      }
-      if (el.shadowRoot) {
-        _findAllElements(el.shadowRoot.querySelectorAll("*"));
-      }
+// src/pwa.ts
+import logger2 from "@wdio/logger";
+var log2 = logger2("@wdio/lighthouse-service:PWA");
+function passed(displayValue, explanation) {
+  return { score: 1, displayValue, explanation };
+}
+function failed(displayValue, explanation) {
+  return { score: 0, displayValue, explanation };
+}
+function parseIconSize(sizes) {
+  if (!sizes || sizes === "any") {
+    return sizes === "any" ? Number.POSITIVE_INFINITY : 0;
+  }
+  return sizes.split(/\s+/).reduce((max, entry) => {
+    const match = entry.match(/^(\d+)x(\d+)$/i);
+    if (!match) {
+      return max;
     }
-  };
-  _findAllElements(document.querySelectorAll("*"));
-  return metas.map((meta) => {
-    const getAttribute = (name) => {
-      const attr = meta.attributes.getNamedItem(name);
-      if (!attr) {
-        return;
+    return Math.max(max, Math.min(Number(match[1]), Number(match[2])));
+  }, 0);
+}
+function hasIconOfSize(icons = [], minSize) {
+  return icons.some((icon) => parseIconSize(icon.sizes) >= minSize);
+}
+async function collectPageState(page) {
+  return page.evaluate(async () => {
+    const manifestLink = document.querySelector('link[rel~="manifest"]');
+    const viewport = document.querySelector('meta[name="viewport"]');
+    const appleTouch = document.querySelector('link[rel~="apple-touch-icon"]');
+    const themeColor = document.querySelector('meta[name="theme-color"]');
+    let manifest = null;
+    let manifestParseError;
+    const manifestHref = manifestLink?.href;
+    if (manifestHref) {
+      try {
+        const response = await fetch(manifestHref, { credentials: "same-origin" });
+        if (!response.ok) {
+          manifestParseError = `Failed to fetch manifest: HTTP ${response.status}`;
+        } else {
+          manifest = await response.json();
+        }
+      } catch (error) {
+        manifestParseError = error instanceof Error ? error.message : String(error);
       }
-      return attr.value;
-    };
+    }
+    let hasServiceWorker = false;
+    try {
+      const registration = await navigator.serviceWorker?.getRegistration();
+      hasServiceWorker = Boolean(registration);
+    } catch {
+      hasServiceWorker = false;
+    }
     return {
-      // @ts-ignore
-      name: meta.name.toLowerCase(),
-      // @ts-ignore
-      content: meta.content,
-      property: getAttribute("property"),
-      // @ts-ignore
-      httpEquiv: meta.httpEquiv ? meta.httpEquiv.toLowerCase() : void 0,
-      charset: getAttribute("charset")
+      url: location.href,
+      manifestHref,
+      manifest,
+      manifestParseError,
+      viewportContent: viewport?.content,
+      appleTouchIconHref: appleTouch?.href,
+      themeColor: themeColor?.content,
+      innerWidth: window.innerWidth,
+      documentWidth: document.documentElement.clientWidth,
+      hasServiceWorker
     };
   });
 }
-
-// src/gatherer/pwa.ts
-var PWAGatherer = class {
-  constructor(_session, _page, _driver) {
-    this._session = _session;
-    this._page = _page;
-    this._driver = _driver;
-    this._frGatherer = new FRGatherer(this._session);
-    this._networkRecorder = new NetworkRecorder();
-    NETWORK_RECORDER_EVENTS.forEach((method) => {
-      this._session.on(method, (params) => this._networkRecorder.dispatch({ method, params }));
-    });
-    this._page.on("load", () => {
-      this._networkRecords = this._networkRecorder.getRawRecords();
-      delete this._networkRecorder;
-      this._networkRecorder = new NetworkRecorder();
-    });
-  }
-  _session;
-  _page;
-  _driver;
-  _frGatherer;
-  _networkRecorder;
-  _networkRecords = [];
-  async gatherData() {
-    const pageUrl = await this._page?.url();
-    const passContext = {
-      url: pageUrl,
-      driver: this._driver
-    };
-    const loadData = {
-      networkRecords: this._networkRecords
-    };
-    const linkElements = new LinkElements();
-    const viewportDimensions = new ViewportDimensions();
-    const { registrations } = await serviceWorkers.getServiceWorkerRegistrations(this._frGatherer);
-    const { versions } = await serviceWorkers.getServiceWorkerVersions(this._frGatherer);
-    return {
-      URL: { requestedUrl: pageUrl, finalUrl: pageUrl },
-      WebAppManifest: await WebAppManifest.getWebAppManifest(this._frGatherer, pageUrl),
-      InstallabilityErrors: await InstallabilityErrors.getInstallabilityErrors(this._frGatherer),
-      MetaElements: await this._driver.evaluate(collectMetaElements, {
-        args: [],
-        useIsolation: true,
-        deps: [pageFunctions.getElementsInDocument]
-      }),
-      ViewportDimensions: await viewportDimensions.afterPass(passContext),
-      ServiceWorker: { versions, registrations },
-      LinkElements: await linkElements.afterPass(passContext, loadData)
-    };
+async function getInstallabilityErrors(session) {
+  try {
+    const result = await session.send("Page.getInstallabilityErrors");
+    return result.installabilityErrors ?? result.errors ?? [];
+  } catch (error) {
+    log2.debug(`Page.getInstallabilityErrors is unavailable: ${error.message}`);
+    return [];
   }
-};
-
-// src/gatherer/trace.ts
-import { EventEmitter } from "node:events";
-import NetworkRecorder2 from "lighthouse/lighthouse-core/lib/network-recorder.js";
-import NetworkMonitor from "lighthouse/lighthouse-core/gather/driver/network-monitor.js";
-import ProtocolSession from "lighthouse/lighthouse-core/fraggle-rock/gather/session.js";
-import { waitForFullyLoaded } from "lighthouse/lighthouse-core/gather/driver/wait-for-condition.js";
-import logger2 from "@wdio/logger";
-
-// src/scripts/registerPerformanceObserverInPage.ts
-function registerPerformanceObserverInPage() {
-  window.____lastLongTask = window.performance.now();
-  const observer = new window.PerformanceObserver((entryList) => {
-    const entries = entryList.getEntries();
-    for (const entry of entries) {
-      if (entry.entryType === "longtask") {
-        const taskEnd = entry.startTime + entry.duration;
-        window.____lastLongTask = Math.max(window.____lastLongTask, taskEnd);
-      }
-    }
-  });
-  observer.observe({ entryTypes: ["longtask"] });
-  window.____lhPerformanceObserver = observer;
 }
-
-// src/gatherer/trace.ts
-var log2 = logger2("@wdio/lighthouse-service:TraceGatherer");
-var TraceGatherer = class extends EventEmitter {
-  constructor(_session, _page, _driver) {
-    super();
+function evaluatePWAChecks(state, installabilityErrors) {
+  const manifest = state.manifest;
+  const icons = manifest?.icons ?? [];
+  const display = manifest?.display;
+  const hasName = Boolean(manifest?.name || manifest?.short_name);
+  const hasStartUrl = Boolean(manifest?.start_url);
+  const hasValidDisplay = ["fullscreen", "standalone", "minimal-ui"].includes(String(display));
+  const preferRelatedApps = manifest?.prefer_related_applications === true;
+  const installableByManifest = Boolean(
+    state.manifestHref && manifest && hasName && hasStartUrl && hasValidDisplay && !preferRelatedApps && hasIconOfSize(icons, 192)
+  );
+  const blockingInstallErrors = installabilityErrors.filter((error) => error.errorId && error.errorId !== "already-installed");
+  const isInstallable = blockingInstallErrors.length === 0 && installableByManifest ? passed("installable-manifest", "Web app manifest meets installability requirements") : failed(
+    "installable-manifest",
+    blockingInstallErrors.length ? `Installability errors: ${blockingInstallErrors.map((error) => error.errorId).join(", ")}` : state.manifestParseError || "Web app manifest does not meet installability requirements"
+  );
+  const serviceWorker = state.hasServiceWorker ? passed("service-worker", "A service worker controls this page") : failed("service-worker", "No service worker registration was found for this page");
+  const splashScreen = manifest && hasName && manifest.background_color && hasIconOfSize(icons, 512) ? passed("splash-screen", "Manifest provides a custom splash screen") : failed("splash-screen", "Manifest is missing name, background_color, or a 512px icon");
+  const themedOmnibox = state.themeColor || manifest?.theme_color ? passed("themed-omnibox", "A theme color is provided via manifest or meta tag") : failed("themed-omnibox", "No theme-color meta tag or manifest.theme_color was found");
+  const hasViewport = Boolean(state.viewportContent && /width=|initial-scale=/i.test(state.viewportContent));
+  const viewport = hasViewport ? passed("viewport", "A viewport meta tag is configured") : failed("viewport", "No usable viewport meta tag was found");
+  const contentFits = !hasViewport || Math.abs(state.innerWidth - state.documentWidth) <= 1;
+  const contentWith = contentFits ? passed("content-width", "Content size matches the viewport") : failed("content-width", `Content width (${state.documentWidth}) does not match viewport width (${state.innerWidth})`);
+  const appleTouchIcon = state.appleTouchIconHref ? passed("apple-touch-icon", "An Apple touch icon is present") : failed("apple-touch-icon", "No apple-touch-icon link was found");
+  const maskableIcon = icons.some((icon) => String(icon.purpose || "").split(/\s+/).includes("maskable")) ? passed("maskable-icon", "Manifest includes a maskable icon") : failed("maskable-icon", "Manifest does not include a maskable icon");
+  return {
+    isInstallable,
+    serviceWorker,
+    splashScreen,
+    themedOmnibox,
+    contentWith,
+    viewport,
+    appleTouchIcon,
+    maskableIcon
+  };
+}
+var PWAAuditor = class {
+  constructor(_session, _page) {
     this._session = _session;
     this._page = _page;
-    this._driver = _driver;
-    NETWORK_RECORDER_EVENTS.forEach((method) => {
-      this._networkListeners[method] = (params) => this._networkStatusMonitor.dispatch({ method, params });
-    });
-    this._protocolSession = new ProtocolSession(_session);
-    this._networkMonitor = new NetworkMonitor(_session);
   }
   _session;
   _page;
-  _driver;
-  _failingFrameLoadIds = [];
-  _pageLoadDetected = false;
-  _networkListeners = {};
-  _frameId;
-  _loaderId;
-  _pageUrl;
-  _networkStatusMonitor;
-  _networkMonitor;
-  _protocolSession;
-  _trace;
-  _traceStart;
-  _clickTraceTimeout;
-  _waitConditionPromises = [];
-  async startTracing(url) {
-    delete this._trace;
-    this._networkStatusMonitor = new NetworkRecorder2();
-    NETWORK_RECORDER_EVENTS.forEach((method) => {
-      this._session.on(method, this._networkListeners[method]);
-    });
-    this._traceStart = Date.now();
-    log2.info(`Start tracing frame with url ${url}`);
-    await this._driver.beginTrace();
-    if (url === CLICK_TRANSITION) {
-      log2.info("Start checking for page load for click");
-      this._clickTraceTimeout = setTimeout(async () => {
-        log2.info("No page load detected, canceling trace");
-        return this.finishTracing();
-      }, FRAME_LOAD_START_TIMEOUT);
-    }
-    await this._page.evaluateOnNewDocument(registerPerformanceObserverInPage);
-    this._waitConditionPromises.push(
-      waitForFullyLoaded(this._protocolSession, this._networkMonitor, { timedOut: 1 })
-    );
-  }
-  /**
-   * store frame id of frames that are being traced
-   */
-  async onFrameNavigated(msgObj) {
-    if (!this.isTracing) {
-      return;
-    }
-    if (this._failingFrameLoadIds.includes(msgObj.frame.url)) {
-      this._waitConditionPromises = [];
-      this._frameId = '"unsuccessful loaded frame"';
-      this.finishTracing();
-      this.emit("tracingError", new Error(`Page with url "${msgObj.frame.url}" failed to load`));
-      if (this._clickTraceTimeout) {
-        clearTimeout(this._clickTraceTimeout);
-      }
-    }
-    if (
-      // we already detected a frameId before
-      this._frameId || // the event was thrown for a sub frame (e.g. iframe)
-      msgObj.frame.parentId || // we don't support the url of given frame
-      !isSupportedUrl(msgObj.frame.url)
-    ) {
-      log2.info(`Ignore navigated frame with url ${msgObj.frame.url}`);
-      return;
-    }
-    this._frameId = msgObj.frame.id;
-    this._loaderId = msgObj.frame.loaderId;
-    this._pageUrl = msgObj.frame.url;
-    log2.info(`Page load detected: ${this._pageUrl}, set frameId ${this._frameId}, set loaderId ${this._loaderId}`);
-    if (this._clickTraceTimeout && !this._pageLoadDetected) {
-      log2.info("Page load detected for click, clearing click trace timeout}");
-      this._pageLoadDetected = true;
-      clearTimeout(this._clickTraceTimeout);
-    }
-    this.emit("tracingStarted", msgObj.frame.id);
-  }
-  /**
-   * once the page load event has fired, we can grab some performance
-   * metrics and timing
-   */
-  async onLoadEventFired() {
-    if (!this.isTracing) {
-      return;
-    }
-    const loadPromise = Promise.all(this._waitConditionPromises).then(() => async () => {
-      const minTraceTime = TRACING_TIMEOUT - (Date.now() - (this._traceStart || 0));
-      if (minTraceTime > 0) {
-        log2.info(`page load happen to quick, waiting ${minTraceTime}ms more`);
-        await new Promise((resolve) => setTimeout(resolve, minTraceTime));
-      }
-      return this.completeTracing();
-    });
-    const cleanupFn = await Promise.race([
-      loadPromise,
-      this.waitForMaxTimeout()
+  async audit(auditsToBeRun = [...PWA_AUDIT_NAMES]) {
+    const [state, installabilityErrors] = await Promise.all([
+      collectPageState(this._page),
+      getInstallabilityErrors(this._session)
     ]);
-    this._waitConditionPromises = [];
-    return cleanupFn();
-  }
-  onFrameLoadFail(request) {
-    const frame = request.frame();
-    if (frame) {
-      this._failingFrameLoadIds.push(frame.url());
-    }
-  }
-  get isTracing() {
-    return typeof this._traceStart === "number";
-  }
-  /**
-   * once tracing has finished capture trace logs into memory
-   */
-  async completeTracing() {
-    const traceDuration = Date.now() - (this._traceStart || 0);
-    log2.info(`Tracing completed after ${traceDuration}ms, capturing performance data for frame ${this._frameId}`);
-    try {
-      const traceEvents = await this._driver.endTrace();
-      const startedInBrowserEvt = traceEvents.traceEvents.find((e) => e.name === "TracingStartedInBrowser");
-      const mainFrame = startedInBrowserEvt && startedInBrowserEvt.args && startedInBrowserEvt.args.data.frames?.find((frame) => !frame.parent);
-      if (mainFrame && mainFrame.processId) {
-        const threadNameEvt = traceEvents.traceEvents.find((e) => e.ph === "R" && e.cat === "blink.user_timing" && e.name === "navigationStart" && e.args.data.isLoadingMainFrame);
-        if (threadNameEvt) {
-          log2.info(`Replace mainFrame process id ${mainFrame.processId} with actual thread process id ${threadNameEvt.pid}`);
-          mainFrame.processId = threadNameEvt.pid;
-        } else {
-          log2.info(`Couldn't replace mainFrame process id ${mainFrame.processId} with actual thread process id`);
-        }
-      }
-      this._trace = {
-        ...traceEvents,
-        frameId: this._frameId,
-        loaderId: this._loaderId,
-        pageUrl: this._pageUrl,
-        traceStart: this._traceStart,
-        traceEnd: Date.now()
-      };
-      this.emit("tracingComplete", this._trace);
-      this.finishTracing();
-    } catch (err) {
-      log2.error(`Error capturing tracing logs: ${err.stack}`);
-      this.emit("tracingError", err);
-      return this.finishTracing();
-    }
-  }
-  /**
-   * clear tracing states and emit tracingFinished
-   */
-  finishTracing() {
-    log2.info(`Tracing for ${this._frameId} completed`);
-    this._pageLoadDetected = false;
-    NETWORK_RECORDER_EVENTS.forEach(
-      (method) => this._session.off(method, this._networkListeners[method])
+    const allDetails = evaluatePWAChecks(state, installabilityErrors);
+    const details = Object.fromEntries(
+      Object.entries(allDetails).filter(([name]) => auditsToBeRun.includes(name))
     );
-    delete this._networkStatusMonitor;
-    delete this._traceStart;
-    delete this._frameId;
-    delete this._loaderId;
-    delete this._pageUrl;
-    this._failingFrameLoadIds = [];
-    this._waitConditionPromises = [];
-    this.emit("tracingFinished");
-  }
-  waitForMaxTimeout(maxWaitForLoadedMs = MAX_TRACE_WAIT_TIME) {
-    return new Promise(
-      (resolve) => setTimeout(resolve, maxWaitForLoadedMs)
-    ).then(() => async () => {
-      log2.error("Neither network nor CPU idle time could be detected within timeout, wrapping up tracing");
-      return this.completeTracing();
-    });
+    return {
+      passed: !Object.values(details).some((result) => result.score < 1),
+      details
+    };
   }
 };
 
 // src/commands.ts
 var log3 = logger3("@wdio/lighthouse-service:CommandHandler");
-var TRACE_COMMANDS = ["click", "navigateTo", "url"];
 function isCDPSessionOnMessageObject(data) {
   return data !== null && typeof data === "object" && Object.prototype.hasOwnProperty.call(data, "params") && Object.prototype.hasOwnProperty.call(data, "method");
 }
+function isTraceCommand(commandName) {
+  return TRACE_COMMANDS.includes(commandName);
+}
 var CommandHandler = class {
-  constructor(_session, _page, _driver, _options, _browser) {
+  constructor(_session, _page, _options, _browser) {
     this._session = _session;
     this._page = _page;
-    this._driver = _driver;
     this._options = _options;
     this._browser = _browser;
     this._networkHandler = new NetworkHandler(_session);
-    this._traceGatherer = new TraceGatherer(_session, _page, _driver);
-    this._pwaGatherer = new PWAGatherer(_session, _page, _driver);
-    _session.on("Page.loadEventFired", this._traceGatherer.onLoadEventFired.bind(this._traceGatherer));
-    _session.on("Page.frameNavigated", this._traceGatherer.onFrameNavigated.bind(this._traceGatherer));
-    _page.on("requestfailed", this._traceGatherer.onFrameLoadFail.bind(this._traceGatherer));
-    this._pwaGatherer = new PWAGatherer(_session, _page, _driver);
+    this._pwaAuditor = new PWAAuditor(_session, _page);
+    _session.on("Page.frameNavigated", this._onFrameNavigated);
     const commands = Object.getOwnPropertyNames(Object.getPrototypeOf(this)).filter(
       (fnName) => fnName !== "constructor" && !fnName.startsWith("_")
     );
     commands.forEach((fnName) => _browser.addCommand(
       fnName,
-      this[fnName].bind(this),
-      {}
-      // Use the non-deprecated overload with options
+      this[fnName].bind(this)
     ));
-    this._devtoolsGatherer = new DevtoolsGatherer();
     _session.on("*", this._propagateWSEvents.bind(this));
   }
   _session;
   _page;
-  _driver;
   _options;
   _browser;
   _isTracing = false;
@@ -852,9 +602,12 @@ var CommandHandler = class {
   _cpuThrottling;
   _networkThrottling;
   _formFactor;
-  _traceGatherer;
-  _devtoolsGatherer;
-  _pwaGatherer;
+  _pwaAuditor;
+  _flow;
+  _flowInProgress = false;
+  _pageLoadDetected = false;
+  _clickTraceTimeout;
+  _onFrameNavigated = this._handleFrameNavigated.bind(this);
   /**
    * Start tracing the browser. You can optionally pass in custom tracing categories and the
    * sampling frequency.
@@ -883,9 +636,11 @@ var CommandHandler = class {
       if (!traceBuffer) {
         throw new Error("No tracebuffer captured");
       }
-      this._traceEvents = JSON.parse(traceBuffer.toString());
+      const parsed = parseTraceBuffer(traceBuffer);
+      this._traceEvents = parsed.traceEvents ?? parsed;
       this._isTracing = false;
     } catch (err) {
+      this._isTracing = false;
       throw new Error(`Couldn't parse trace events: ${err.message}`);
     }
     return this._traceEvents;
@@ -942,15 +697,12 @@ var CommandHandler = class {
     await this._session.send("Network.emulateNetworkConditions", NETWORK_STATES[networkThrottling]);
   }
   async checkPWA(auditsToBeRun) {
-    const auditor = new Auditor();
-    const artifacts = await this._pwaGatherer.gatherData();
-    return auditor._auditPWA(artifacts, auditsToBeRun);
+    return this._pwaAuditor.audit(auditsToBeRun);
   }
   _propagateWSEvents(data) {
     if (!isCDPSessionOnMessageObject(data)) {
       return;
     }
-    this._devtoolsGatherer?.onMessage(data);
     const method = data.method || "event";
     try {
       log3.debug(`cdp event: ${method} with params ${JSON.stringify(data.params)}`);
@@ -967,24 +719,57 @@ var CommandHandler = class {
       ])
     ));
   }
-  _beforeCmd(commandName, params) {
-    const isCommandNavigation = ["url", "navigateTo"].some((cmdName) => cmdName === commandName);
-    if (!this._shouldRunPerformanceAudits || !this._traceGatherer || this._traceGatherer.isTracing || !TRACE_COMMANDS.includes(commandName)) {
+  async _beforeCmd(commandName, params) {
+    const isCommandNavigation = ["url", "navigateTo"].includes(commandName);
+    if (!this._shouldRunPerformanceAudits || this._flowInProgress || !isTraceCommand(commandName)) {
       return;
     }
-    this.setThrottlingProfile(this._networkThrottling, this._cpuThrottling, this._cacheEnabled);
+    await this.setThrottlingProfile(this._networkThrottling, this._cpuThrottling, this._cacheEnabled);
     const url = isCommandNavigation ? params[0] : CLICK_TRANSITION;
-    return this._traceGatherer.startTracing(url);
+    this._pageLoadDetected = false;
+    this._flowInProgress = true;
+    if (url === CLICK_TRANSITION) {
+      this._clickTraceTimeout = setTimeout(() => {
+        if (!this._pageLoadDetected) {
+          log3.info("No page load detected, canceling Lighthouse navigation");
+        }
+      }, FRAME_LOAD_START_TIMEOUT);
+    }
+    try {
+      await this._refreshAuditablePage();
+      this._flow = await startFlow(this._page, this._getFlowOptions());
+      await this._flow.startNavigation({ name: `WebdriverIO ${commandName}` });
+    } catch (error) {
+      this._resetFlowState();
+      throw error;
+    }
   }
-  _afterCmd(commandName) {
-    if (!this._traceGatherer || !this._traceGatherer.isTracing || !TRACE_COMMANDS.includes(commandName)) {
+  async _afterCmd(commandName) {
+    if (!this._flow || !this._flowInProgress || !isTraceCommand(commandName)) {
       return;
     }
-    this._traceGatherer.once("tracingComplete", (traceEvents) => {
-      const auditor = new Auditor(traceEvents, this._devtoolsGatherer?.getLogs(), this._formFactor);
+    const skipClickWithoutNavigation = commandName === "click" && !this._pageLoadDetected;
+    try {
+      if (skipClickWithoutNavigation) {
+        log3.info("Click did not trigger a page load, skipping Lighthouse navigation");
+        await this._cancelNavigation("click did not trigger a page load");
+        return;
+      }
+      await this._flow.endNavigation();
+      let lhr = selectLighthouseResult(await this._flow.createFlowResult());
+      if (!hasCorePerformanceMetrics(lhr)) {
+        log3.warn(`Wrapped navigation produced no performance metrics (${describeLighthouseResult(lhr)})`);
+        lhr = await this._navigateWithLighthouse() ?? lhr;
+      }
+      if (!hasCorePerformanceMetrics(lhr)) {
+        throw new Error(`Lighthouse did not capture core performance metrics (${describeLighthouseResult(lhr)})`);
+      }
+      log3.info(`Captured Lighthouse performance metrics (${describeLighthouseResult(lhr)})`);
+      const auditor = new Auditor(lhr, this._formFactor);
       auditor.updateCommands(this._browser);
-    });
-    this._traceGatherer.once("tracingError", (err) => {
+    } catch (err) {
+      log3.error(`Couldn't capture performance due to: ${err.message}`);
+      this._disposeFlow();
       const auditor = new Auditor();
       auditor.updateCommands(
         this._browser,
@@ -993,16 +778,107 @@ var CommandHandler = class {
           throw new Error(`Couldn't capture performance due to: ${err.message}`);
         }
       );
-    });
-    return new Promise((resolve) => {
-      log3.info(`Wait until tracing for command ${commandName} finishes`);
-      this._traceGatherer?.once("tracingFinished", async () => {
-        log3.info("Disable throttling");
-        await this.setThrottlingProfile("online", 0, true);
-        log3.info("continuing with next WebDriver command");
-        resolve();
-      });
-    });
+    } finally {
+      this._resetFlowState();
+      log3.info("Disable throttling");
+      await this.setThrottlingProfile("online", 0, true);
+    }
+  }
+  _getFlowOptions() {
+    const requestedFormFactor = this._formFactor;
+    const formFactor = requestedFormFactor === "mobile" ? "mobile" : "desktop";
+    return {
+      name: "WebdriverIO performance flow",
+      config: formFactor === "desktop" ? desktopConfig : void 0,
+      flags: {
+        formFactor,
+        /**
+         * Let Lighthouse apply its own desktop/mobile viewport. The Puppeteer
+         * connection uses `defaultViewport: null`, and headless Chrome on some
+         * CI hosts otherwise paints into a 0×0 window (no FCP / empty LHR).
+         */
+        ...requestedFormFactor === "none" ? { screenEmulation: { disabled: true } } : {},
+        throttlingMethod: "provided",
+        disableStorageReset: true,
+        skipAboutBlank: true,
+        onlyCategories: ["performance"],
+        logLevel: "error"
+      }
+    };
+  }
+  _handleFrameNavigated(event) {
+    if (!this._flowInProgress || event.frame?.parentId || !event.frame?.url || !isSupportedUrl(event.frame.url)) {
+      return;
+    }
+    this._pageLoadDetected = true;
+    if (this._clickTraceTimeout) {
+      clearTimeout(this._clickTraceTimeout);
+      this._clickTraceTimeout = void 0;
+    }
+  }
+  async _refreshAuditablePage() {
+    try {
+      const puppeteer = this._page.browser();
+      const currentUrl = await this._browser.getUrl();
+      const page = await getAuditablePuppeteerPage(puppeteer, currentUrl);
+      if (page) {
+        this._page = page;
+      }
+    } catch (error) {
+      log3.debug(`Could not refresh Puppeteer page: ${error.message}`);
+    }
+  }
+  async _navigateWithLighthouse() {
+    const currentUrl = await this._browser.getUrl();
+    if (!isSupportedUrl(currentUrl)) {
+      log3.warn(`Cannot fall back to Lighthouse navigate for unsupported url: ${currentUrl}`);
+      return void 0;
+    }
+    log3.info(`Falling back to Lighthouse-controlled navigation (${currentUrl})`);
+    await this._refreshAuditablePage();
+    if (!this._flow?.navigate) {
+      this._disposeFlow();
+      this._flow = await startFlow(this._page, this._getFlowOptions());
+    }
+    await this._flow.navigate(currentUrl);
+    return selectLighthouseResult(await this._flow.createFlowResult());
+  }
+  async _cancelNavigation(reason) {
+    this._disposeFlow();
+    try {
+      await Promise.race([
+        this._flow?.endNavigation() ?? Promise.resolve(),
+        new Promise((_, reject) => {
+          setTimeout(() => reject(new Error(reason)), FRAME_LOAD_START_TIMEOUT);
+        })
+      ]);
+    } catch (error) {
+      log3.debug(`Lighthouse navigation cancelled: ${error.message}`);
+    }
+    const auditor = new Auditor();
+    auditor.updateCommands(
+      this._browser,
+      /* istanbul ignore next */
+      () => {
+        throw new Error(`Couldn't capture performance due to: ${reason}`);
+      }
+    );
+  }
+  _disposeFlow() {
+    try {
+      this._flow?.dispose?.();
+    } catch (error) {
+      log3.debug(`Failed to dispose Lighthouse flow: ${error.message}`);
+    }
+  }
+  _resetFlowState() {
+    if (this._clickTraceTimeout) {
+      clearTimeout(this._clickTraceTimeout);
+      this._clickTraceTimeout = void 0;
+    }
+    this._flow = void 0;
+    this._flowInProgress = false;
+    this._pageLoadDetected = false;
   }
 };
 
@@ -1043,33 +919,21 @@ var DevToolsService = class {
     if (typeof cpuThrottling !== "number") {
       throw new Error(`CPU throttling rate needs to be typeof number but was "${typeof cpuThrottling}"`);
     }
-    if (this._command.length === 1) {
-      this._command[0].enablePerformanceAudits({ networkThrottling, cpuThrottling, cacheEnabled, formFactor });
-    } else {
-      for (const c of this._command) {
-        c.enablePerformanceAudits({ networkThrottling, cpuThrottling, cacheEnabled, formFactor });
-      }
+    for (const c of this._command) {
+      c.enablePerformanceAudits({ networkThrottling, cpuThrottling, cacheEnabled, formFactor });
     }
   }
   /**
    * custom command to disable performance audits
    */
   _disablePerformanceAudits() {
-    if (this._command.length === 1) {
-      this._command[0].disablePerformanceAudits();
-    } else {
-      for (const c of this._command) {
-        c.disablePerformanceAudits();
-      }
+    for (const c of this._command) {
+      c.disablePerformanceAudits();
     }
   }
   async _setThrottlingProfile(networkThrottling = DEFAULT_THROTTLE_STATE.networkThrottling, cpuThrottling = DEFAULT_THROTTLE_STATE.cpuThrottling, cacheEnabled = DEFAULT_THROTTLE_STATE.cacheEnabled) {
-    if (this._command.length === 1) {
-      this._command[0].setThrottlingProfile(networkThrottling, cpuThrottling, cacheEnabled);
-    } else {
-      for (const c of this._command) {
-        c.setThrottlingProfile(networkThrottling, cpuThrottling, cacheEnabled);
-      }
+    for (const c of this._command) {
+      c.setThrottlingProfile(networkThrottling, cpuThrottling, cacheEnabled);
     }
   }
   async _checkPWA(auditsToBeRun) {
@@ -1090,22 +954,12 @@ var DevToolsService = class {
         return setUnsupportedCommand(browser2);
       }
       const url = await browser2.getUrl();
-      const target = url !== "data:," ? await puppeteer.waitForTarget(
-        async (t) => t.url().includes(url) && !t.url().includes("BiDi-CDP Mapper") && Boolean(await t.page())
-      ) : await puppeteer.waitForTarget(
-        async (t) => t.type() === "page" || // @ts-expect-error
-        Boolean(t._getTargetInfo().browserContextId) && !!await t.page()
-      );
-      if (!target) {
-        throw new Error("No page target found");
-      }
-      const page = await target.page();
+      const page = await getAuditablePuppeteerPage(puppeteer, url);
       if (!page) {
         throw new Error("No page found");
       }
-      const session = await target.createCDPSession();
-      const driver = await getLighthouseDriver(session, target);
-      const cmd = new CommandHandler(session, page, driver, this._options, browser2);
+      const session = await page.target().createCDPSession();
+      const cmd = new CommandHandler(session, page, this._options, browser2);
       await cmd._initCommand();
       this._command.push(cmd);
     }