browsertime 27.0.0 → 27.0.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Browsertime changelog (we do [semantic versioning](https://semver.org))
 
+## 27.0.2 - 2026-05-02
+
+### Fixed
+* SPA scripts no longer drop a HAR page when Chrome's soft-navigation `PerformanceObserver` entry doesn't fire. [#2438](https://github.com/sitespeedio/browsertime/pull/2438) gated HAR-page creation on Chrome detecting all three soft-navigation criteria (interaction + URL change + visible paint within a short window), but real SPAs like Grafana sometimes paint too late and Chrome never emits the entry — chrome-har then sees only `Network.*` events for that measurement and emits zero pages, breaking downstream per-iteration page indexing in sitespeed.io. When the measurement was started without a URL (`commands.measure.start(alias)` form) and no soft-nav entry was detected, fall back to a synthetic page anchored at the current `location.href` so each `measure.start` produces exactly one HAR page.
+
+## 27.0.1 - 2026-05-02
+
+### Fixed
+* `commands.click` now falls back to a JavaScript click when the Actions API can't reach the element. Hidden elements have a zero-size bounding box, so the Actions API click that became the default in [#2381](https://github.com/sitespeedio/browsertime/pull/2381) silently moved the pointer to (0,0) and clicked nothing instead of triggering the handler. The click command now pre-checks `isDisplayed()` and uses a JS click when the element isn't displayed, and otherwise catches any Actions API failure and retries with a JS click. Each fallback is logged at info level so it's visible without `--verbose`. Restores the documented "hide everything before clicking" pattern used by visual-metric scripts [#2452](https://github.com/sitespeedio/browsertime/pull/2452).
+* `engineDelegate.afterBrowserStopped()` is no longer called twice per iteration on the happy path. [#2432](https://github.com/sitespeedio/browsertime/pull/2432) added a safety-net cleanup call in the iteration `finally` block so failure paths still release long-lived helpers, but in the happy path `_stopBrowser` had already invoked the cleanup, so it ran twice. The visible symptom on Chrome was a spurious `ENOENT` error from the second `cleanUserDataDir` (the first call had already removed the directory). It could also double-terminate the iOS simulator's Safari and the `ios-capture` server. The safety-net now runs only when `_stopBrowser` didn't already reach the cleanup [#2453](https://github.com/sitespeedio/browsertime/pull/2453).
+* `cleanUserDataDir` cleanup now uses `rm(..., { recursive: true, force: true })` so a missing directory is treated as already-cleaned. Defense in depth alongside [#2453](https://github.com/sitespeedio/browsertime/pull/2453): if anything in the future double-calls the Chrome cleanup, or if Chrome failed to create the directory in the first place, the cleanup stays quiet instead of logging a spurious `ENOENT` [#2454](https://github.com/sitespeedio/browsertime/pull/2454).
+
 ## 27.0.0 - 2026-05-01
 
 ### Highlights

package/lib/chrome/har.js

@@ -23,10 +23,17 @@ export async function getHar(
   const logs = await runner.getLogs(Type.PERFORMANCE);
   const messages = logs.map(entry => JSON.parse(entry.message).message);
 
-  // Inject a SoftNavigation.detected event so chrome-har renames the
-  // current HAR page with the soft navigation URL. The PerformanceObserver
-  // API is the only reliable source that confirms all three soft navigation
-  // criteria (user interaction + URL change + visible paint).
+  // Inject a SoftNavigation.detected event so chrome-har emits/renames a
+  // HAR page for this measurement. Chrome's PerformanceObserver
+  // soft-navigation entry is the trustworthy signal (user interaction +
+  // URL change + visible paint), but it doesn't always fire — Grafana and
+  // similar SPAs can defer their post-route paint past Chrome's window —
+  // so when this measurement was started without a URL (the
+  // `commands.measure.start(alias)` form, signalling "the next page is a
+  // soft-navigation I'm about to drive") we fall back to the current
+  // location.href. Without the fallback, chrome-har silently emits zero
+  // pages for that measurement and downstream consumers (sitespeed.io's
+  // per-iteration page indexing) drift out of alignment.
   try {
     const softNavEntries = await runner.runScript(
       `const supported = PerformanceObserver.supportedEntryTypes;
@@ -44,6 +51,17 @@ export async function getHar(
         method: 'SoftNavigation.detected',
         params: { url: entry.url, startTime: entry.startTime }
       });
+    } else if (!result.url) {
+      const fallbackUrl = await runner.runScript(
+        'return window.location.href;',
+        'GET_URL_FOR_HAR_FALLBACK'
+      );
+      if (fallbackUrl) {
+        messages.push({
+          method: 'SoftNavigation.detected',
+          params: { url: fallbackUrl, startTime: 0 }
+        });
+      }
     }
   } catch {
     // Soft navigations not supported, ignore

package/lib/chrome/webdriver/chromium.js

@@ -584,7 +584,7 @@ export class Chromium {
         if (arg.includes('user-data-dir')) {
           const userDataDir = arg.split('=')[1];
           try {
-            await rm(userDataDir, { recursive: true });
+            await rm(userDataDir, { recursive: true, force: true });
             log.info(`Deleted user data dir: ${userDataDir}`);
           } catch (error) {
             log.error(`Could not delete user data dir: ${userDataDir}`, error);

package/lib/core/engine/command/click.js

@@ -6,9 +6,9 @@ const log = getLogger('browsertime.command.click');
 
 /**
  * Provides functionality to perform click actions on elements in a web page using various selectors.
- * Uses the Selenium Actions API to generate real OS-level mouse events, which means
- * the element must be visible and interactable. If you need to click a hidden element,
- * use {@link JavaScript#run commands.js.run} to trigger a JavaScript click instead.
+ * Tries the Selenium Actions API first to generate real OS-level mouse events; if the element is
+ * not interactable (commonly because the page hides content before clicking — a recommended
+ * pattern for visual-metric scripts), falls back to a JavaScript click so the script keeps working.
  *
  * @class
  * @hideconstructor
@@ -55,8 +55,37 @@ export class Click {
    */
   async _clickElement(element) {
     const driver = this.browser.getDriver();
-    await driver.actions({ async: true }).click(element).perform();
-    return driver.actions().clear();
+    // The Actions API moves the pointer to the element's bounding-box center
+    // and clicks. A `display:none` element has a zero-size box, so the click
+    // silently lands at (0,0) instead of throwing — we have to detect that
+    // up front and use JS instead. Other interactability problems (overlays,
+    // pointer-events:none, etc.) that do throw are caught below.
+    const isDisplayed = await element.isDisplayed().catch(() => false);
+    if (!isDisplayed) {
+      log.info(
+        'Element is not displayed — using a JavaScript click instead of the Actions API.'
+      );
+      return driver.executeScript('arguments[0].click();', element);
+    }
+    try {
+      await driver.actions({ async: true }).click(element).perform();
+      return driver.actions().clear();
+    } catch (error) {
+      log.info(
+        'Actions API click failed (%s) — falling back to a JavaScript click.',
+        error && error.name
+      );
+      try {
+        await driver.actions().clear();
+        await driver.executeScript('arguments[0].click();', element);
+      } catch (jsError) {
+        log.error(
+          'Both the Actions API and the JavaScript click failed: %s',
+          (jsError && jsError.message) || jsError
+        );
+        throw jsError;
+      }
+    }
   }
 
   /**

package/lib/core/engine/iteration.js

@@ -82,6 +82,7 @@ export class Iteration {
     const batteryTemperature = {};
 
     const engineDelegate = this.engineDelegate;
+    let afterBrowserStoppedRan = false;
 
     try {
       await this._startBrowser(browser, engineDelegate, options);
@@ -153,6 +154,7 @@ export class Iteration {
         index,
         commands
       );
+      afterBrowserStoppedRan = true;
 
       if (isAndroidConfigured(options)) {
         batteryTemperature.stop = await this.android.getTemperature();
@@ -206,10 +208,16 @@ export class Iteration {
       }
       // Ensure delegate cleanup runs even on failure paths so that
       // long-lived helpers (e.g. ios-capture, safaridriver) are released.
-      try {
-        await engineDelegate.afterBrowserStopped();
-      } catch {
-        // Idempotent — may have already run via _stopBrowser
+      // Skip when _stopBrowser already reached afterBrowserStopped on the
+      // happy path — running the cleanup twice surfaced as ENOENT noise on
+      // the Chrome user-data dir cleanup and could double-kill processes
+      // on Safari.
+      if (!afterBrowserStoppedRan) {
+        try {
+          await engineDelegate.afterBrowserStopped();
+        } catch {
+          // best-effort — helpers may already have been released
+        }
       }
     }
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "browsertime",
   "description": "Get performance metrics from your web page using Browsertime.",
-  "version": "27.0.0",
+  "version": "27.0.2",
   "bin": "./bin/browsertime.js",
   "type": "module",
   "types": "./types/scripting.d.ts",

package/types/core/engine/command/click.d.ts

@@ -1,8 +1,8 @@
 /**
  * Provides functionality to perform click actions on elements in a web page using various selectors.
- * Uses the Selenium Actions API to generate real OS-level mouse events, which means
- * the element must be visible and interactable. If you need to click a hidden element,
- * use {@link JavaScript#run commands.js.run} to trigger a JavaScript click instead.
+ * Tries the Selenium Actions API first to generate real OS-level mouse events; if the element is
+ * not interactable (commonly because the page hides content before clicking — a recommended
+ * pattern for visual-metric scripts), falls back to a JavaScript click so the script keeps working.
  *
  * @class
  * @hideconstructor

package/types/core/engine/command/click.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"click.d.ts","sourceRoot":"","sources":["../../../../lib/core/engine/command/click.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH;IACE,gEAaC;IAZC;;OAEG;IACH,gBAAsB;IACtB;;OAEG;IACH,0BAA0C;IAC1C;;OAEG;IACH,gBAAsB;IAGxB;;OAEG;IACH,wBAKC;IAED;;OAEG;IACH,iBAMC;IAED;;OAEG;IACH,sBAIC;IAED;;;;;;;;;;;OAWG;IACH,cANW,MAAM,YAEd;QAA0B,iBAAiB,GAAnC,OAAO;KACf,GAAU,OAAO,CAAC,IAAI,CAAC,CAoBzB;IAED;;;;;;;;OAQG;IACH,oBAcC;IAED;;;;;;;;OAQG;IACH,2BAEC;IAED;;;;;;;;OAQG;IACH,mBAQC;IAED;;;;;;;;OAQG;IACH,0BAQC;IAED;;;;;;;;OAQG;IACH,0BAQC;IAED;;;;;;;;OAQG;IACH,iCAQC;IAED;;;;;;;;;OASG;IACH,eAQC;IAED;;;;;;;;;OASG;IACH,sBAQC;IAED;;;;;;;;OAQG;IACH,gBAcC;IACD;;;;;;;;OAQG;IACH,uBAEC;IAED;;;;;;;;OAQG;IACH,aAeC;IAED;;;;;;;;OAQG;IACH,oBAEC;IAED;;;;;;;;OAQG;IACH,aAcC;IAED;;;;;;;;OAQG;IACH,eAcC;IAED;;;;;;OAMG;IACH,oBAEC;IAED;;;;;;;;OAQG;IACH,mBAcC;IAED;;;;;;;;OAQG;IACH,0BAEC;CACF"}
+{"version":3,"file":"click.d.ts","sourceRoot":"","sources":["../../../../lib/core/engine/command/click.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH;IACE,gEAaC;IAZC;;OAEG;IACH,gBAAsB;IACtB;;OAEG;IACH,0BAA0C;IAC1C;;OAEG;IACH,gBAAsB;IAGxB;;OAEG;IACH,wBAKC;IAED;;OAEG;IACH,iBAMC;IAED;;OAEG;IACH,sBAiCC;IAED;;;;;;;;;;;OAWG;IACH,cANW,MAAM,YAEd;QAA0B,iBAAiB,GAAnC,OAAO;KACf,GAAU,OAAO,CAAC,IAAI,CAAC,CAoBzB;IAED;;;;;;;;OAQG;IACH,oBAcC;IAED;;;;;;;;OAQG;IACH,2BAEC;IAED;;;;;;;;OAQG;IACH,mBAQC;IAED;;;;;;;;OAQG;IACH,0BAQC;IAED;;;;;;;;OAQG;IACH,0BAQC;IAED;;;;;;;;OAQG;IACH,iCAQC;IAED;;;;;;;;;OASG;IACH,eAQC;IAED;;;;;;;;;OASG;IACH,sBAQC;IAED;;;;;;;;OAQG;IACH,gBAcC;IACD;;;;;;;;OAQG;IACH,uBAEC;IAED;;;;;;;;OAQG;IACH,aAeC;IAED;;;;;;;;OAQG;IACH,oBAEC;IAED;;;;;;;;OAQG;IACH,aAcC;IAED;;;;;;;;OAQG;IACH,eAcC;IAED;;;;;;OAMG;IACH,oBAEC;IAED;;;;;;;;OAQG;IACH,mBAcC;IAED;;;;;;;;OAQG;IACH,0BAEC;CACF"}