@percy/core 1.31.0-alpha.2 → 1.31.0

package/dist/api.js

@@ -1,13 +1,30 @@
 import fs from 'fs';
-import path from 'path';
-import { createRequire } from 'module';
+import path, { dirname, resolve } from 'path';
 import logger from '@percy/logger';
 import { normalize } from '@percy/config/utils';
 import { getPackageJSON, Server, percyAutomateRequestHandler, percyBuildEventHandler } from './utils.js';
 import WebdriverUtils from '@percy/webdriver-utils';
 import { handleSyncJob } from './snapshot.js';
-// need require.resolve until import.meta.resolve can be transpiled
-export const PERCY_DOM = createRequire(import.meta.url).resolve('@percy/dom');
+// Previously, we used `createRequire(import.meta.url).resolve` to resolve the path to the module.
+// This approach relied on `createRequire`, which is Node.js-specific and less compatible with modern ESM (ECMAScript Module) standards.
+// This was leading to hard coded paths when CLI is used as a dependency in another project.
+// Now, we use `fileURLToPath` and `path.resolve` to determine the absolute path in a way that's more aligned with ESM conventions.
+// This change ensures better compatibility and avoids relying on Node.js-specific APIs that might cause issues in ESM environments.
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+export const getPercyDomPath = url => {
+  try {
+    return createRequire(url).resolve('@percy/dom');
+  } catch (error) {
+    logger('core:server').warn(['Failed to resolve @percy/dom path using createRequire.', 'Falling back to using fileURLToPath and path.resolve.'].join(' '));
+  }
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  return resolve(__dirname, 'node_modules/@percy/dom');
+};
+
+// Resolved path for PERCY_DOM
+export const PERCY_DOM = getPercyDomPath(import.meta.url);
 
 // Returns a URL encoded string of nested query params
 function encodeURLSearchParams(subj, prefix) {

package/dist/browser.js

@@ -72,7 +72,7 @@ export class Browser extends EventEmitter {
     this.readyState = 0;
     let {
       cookies = [],
-      launchOptions = {}
+      launchOptions
     } = this.percy.config.discovery;
     let {
       executable,
@@ -123,8 +123,14 @@ export class Browser extends EventEmitter {
     var _this$ws;
     return ((_this$ws = this.ws) === null || _this$ws === void 0 ? void 0 : _this$ws.readyState) === WebSocket.OPEN;
   }
-  async close() {
-    var _this$process, _this$ws2;
+  async close(force = false) {
+    var _this$percy$config$di, _this$process, _this$ws2;
+    // Check for the new closeBrowser option
+    if (!force && ((_this$percy$config$di = this.percy.config.discovery) === null || _this$percy$config$di === void 0 || (_this$percy$config$di = _this$percy$config$di.launchOptions) === null || _this$percy$config$di === void 0 ? void 0 : _this$percy$config$di.closeBrowser) === false) {
+      this.log.debug('Skipping browser close due to closeBrowser:false option');
+      return true;
+    }
+
     // not running, already closed, or closing
     if (this._closed) return this._closed;
     this.readyState = 2;

package/dist/config.js

@@ -16,12 +16,43 @@ export const configSchema = {
       },
       labels: {
         type: 'string'
+      },
+      skipBaseBuild: {
+        type: 'boolean',
+        default: false
       }
     }
   },
   snapshot: {
     type: 'object',
     additionalProperties: false,
+    definitions: {
+      configurationProperties: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          diffSensitivity: {
+            type: 'integer',
+            minimum: 0,
+            maximum: 4
+          },
+          imageIgnoreThreshold: {
+            type: 'number',
+            minimum: 0,
+            maximum: 1
+          },
+          carouselsEnabled: {
+            type: 'boolean'
+          },
+          bannersEnabled: {
+            type: 'boolean'
+          },
+          adsEnabled: {
+            type: 'boolean'
+          }
+        }
+      }
+    },
     properties: {
       widths: {
         type: 'array',
@@ -91,6 +122,14 @@ export const configSchema = {
       thTestCaseExecutionId: {
         type: 'string'
       },
+      browsers: {
+        type: 'array',
+        items: {
+          type: 'string',
+          minLength: 1
+        },
+        onlyWeb: true
+      },
       fullPage: {
         type: 'boolean',
         onlyAutomate: true
@@ -160,6 +199,88 @@ export const configSchema = {
             }
           }
         }
+      },
+      regions: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            elementSelector: {
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                boundingBox: {
+                  type: 'object',
+                  additionalProperties: false,
+                  properties: {
+                    x: {
+                      type: 'integer'
+                    },
+                    y: {
+                      type: 'integer'
+                    },
+                    width: {
+                      type: 'integer'
+                    },
+                    height: {
+                      type: 'integer'
+                    }
+                  }
+                },
+                elementXpath: {
+                  type: 'string'
+                },
+                elementCSS: {
+                  type: 'string'
+                }
+              }
+            },
+            padding: {
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                top: {
+                  type: 'integer'
+                },
+                bottom: {
+                  type: 'integer'
+                },
+                left: {
+                  type: 'integer'
+                },
+                right: {
+                  type: 'integer'
+                }
+              }
+            },
+            algorithm: {
+              type: 'string',
+              enum: ['standard', 'layout', 'ignore', 'intelliignore']
+            },
+            configuration: {
+              $ref: '#/definitions/configurationProperties'
+            },
+            assertion: {
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                diffIgnoreThreshold: {
+                  type: 'number',
+                  minimum: 0,
+                  maximum: 1
+                }
+              }
+            }
+          },
+          required: ['algorithm']
+        }
+      },
+      algorithm: {
+        type: 'string',
+        enum: ['standard', 'layout', 'intelliignore']
+      },
+      algorithmConfiguration: {
+        $ref: '#/definitions/configurationProperties'
       }
     }
   },
@@ -217,6 +338,10 @@ export const configSchema = {
         minimum: 1,
         maximum: 30000
       },
+      scrollToBottom: {
+        type: 'boolean',
+        default: false
+      },
       disableCache: {
         type: 'boolean'
       },
@@ -306,6 +431,10 @@ export const configSchema = {
           },
           headless: {
             type: 'boolean'
+          },
+          closeBrowser: {
+            type: 'boolean',
+            default: true
           }
         }
       }
@@ -363,9 +492,21 @@ export const snapshotSchema = {
         thTestCaseExecutionId: {
           $ref: '/config/snapshot#/properties/thTestCaseExecutionId'
         },
+        browsers: {
+          $ref: '/config/snapshot#/properties/browsers'
+        },
         reshuffleInvalidTags: {
           $ref: '/config/snapshot#/properties/reshuffleInvalidTags'
         },
+        regions: {
+          $ref: '/config/snapshot#/properties/regions'
+        },
+        algorithm: {
+          $ref: '/config/snapshot#/properties/algorithm'
+        },
+        algorithmConfiguration: {
+          $ref: '/config/snapshot#/properties/algorithmConfiguration'
+        },
         scopeOptions: {
           $ref: '/config/snapshot#/properties/scopeOptions'
         },
@@ -408,6 +549,9 @@ export const snapshotSchema = {
             },
             retry: {
               $ref: '/config/discovery#/properties/retry'
+            },
+            scrollToBottom: {
+              $ref: '/config/discovery#/properties/scrollToBottom'
             }
           }
         }
@@ -909,6 +1053,15 @@ export const comparisonSchema = {
         ignoreElementsData: regionsSchema
       }
     },
+    regions: {
+      $ref: '/config/snapshot#/properties/regions'
+    },
+    algorithm: {
+      $ref: '/config/snapshot#/properties/algorithm'
+    },
+    algorithmConfiguration: {
+      $ref: '/config/snapshot#/properties/algorithmConfiguration'
+    },
     consideredElementsData: {
       type: 'object',
       additionalProperties: false,

package/dist/discovery.js

@@ -1,7 +1,7 @@
 import logger from '@percy/logger';
 import Queue from './queue.js';
 import Page from './page.js';
-import { normalizeURL, hostnameMatches, createResource, createRootResource, createPercyCSSResource, createLogResource, yieldAll, snapshotLogName, waitForTimeout, withRetries, waitForSelectorInsideBrowser } from './utils.js';
+import { normalizeURL, hostnameMatches, createResource, createRootResource, createPercyCSSResource, createLogResource, yieldAll, snapshotLogName, waitForTimeout, withRetries, waitForSelectorInsideBrowser, isGzipped, maybeScrollToBottom } from './utils.js';
 import { sha256hash } from '@percy/client/utils';
 import Pako from 'pako';
 
@@ -36,6 +36,7 @@ function debugSnapshotOptions(snapshot) {
   debugProp(snapshot, 'waitForTimeout');
   debugProp(snapshot, 'waitForSelector');
   debugProp(snapshot, 'scopeOptions.scroll');
+  debugProp(snapshot, 'browsers');
   debugProp(snapshot, 'execute.afterNavigation');
   debugProp(snapshot, 'execute.beforeResize');
   debugProp(snapshot, 'execute.afterResize');
@@ -52,6 +53,7 @@ function debugSnapshotOptions(snapshot) {
   debugProp(snapshot, 'clientInfo');
   debugProp(snapshot, 'environmentInfo');
   debugProp(snapshot, 'domSnapshot', Boolean);
+  debugProp(snapshot, 'discovery.scrollToBottom');
   if (Array.isArray(snapshot.domSnapshot)) {
     debugProp(snapshot, 'domSnapshot.0.userAgent');
   } else {
@@ -107,6 +109,11 @@ function waitForDiscoveryNetworkIdle(page, options) {
   let filter = r => hostnameMatches(allowedHostnames, r.url);
   return page.network.idle(filter, networkIdleTimeout, captureResponsiveAssetsEnabled);
 }
+async function waitForFontLoading(page) {
+  return await logger.measure('core:discovery', 'waitForFontLoading', undefined, async () => {
+    return await Promise.race([page.eval('await document.fonts.ready;'), new Promise(res => setTimeout(res, 5000))]);
+  });
+}
 
 // Creates an initial resource map for a snapshot containing serialized DOM
 function parseDomResources({
@@ -217,8 +224,12 @@ function processSnapshotResources({
   })));
   if (process.env.PERCY_GZIP) {
     for (let index = 0; index < resources.length; index++) {
-      resources[index].content = Pako.gzip(resources[index].content);
-      resources[index].sha = sha256hash(resources[index].content);
+      const alreadyZipped = isGzipped(resources[index].content);
+      /* istanbul ignore next: very hard to mock true */
+      if (!alreadyZipped) {
+        resources[index].content = Pako.gzip(resources[index].content);
+        resources[index].sha = sha256hash(resources[index].content);
+      }
     }
   }
   return {
@@ -264,6 +275,7 @@ async function* captureSnapshotResources(page, snapshot, options) {
         deviceScaleFactor: device.deviceScaleFactor,
         mobile: true
       });
+      yield waitForFontLoading(page);
       yield waitForDiscoveryNetworkIdle(page, discovery);
     }
   }
@@ -317,6 +329,7 @@ async function* captureSnapshotResources(page, snapshot, options) {
     yield page.eval((_, s) => window.__PERCY__.snapshot = s, snapshot);
     yield page.evaluate(snapshot.execute.afterNavigation);
   }
+  yield* maybeScrollToBottom(page, discovery);
 
   // Running before page idle since this will trigger many network calls
   // so need to run as early as possible. plus it is just reading urls from dom srcset
@@ -345,6 +358,7 @@ async function* captureSnapshotResources(page, snapshot, options) {
       for (let i = 0; i < widths.length - 1; i++) {
         if (captureWidths) yield* takeSnapshot(snap, width);
         yield page.evaluate(execute === null || execute === void 0 ? void 0 : execute.beforeResize);
+        yield waitForFontLoading(page);
         yield waitForDiscoveryNetworkIdle(page, discovery);
         yield resizePage(width = widths[i + 1]);
         if (snapshot.responsiveSnapshotCapture) {
@@ -354,6 +368,7 @@ async function* captureSnapshotResources(page, snapshot, options) {
           });
         }
         yield page.evaluate(execute === null || execute === void 0 ? void 0 : execute.afterResize);
+        yield* maybeScrollToBottom(page, discovery);
       }
     }
     if (capture && !snapshot.domSnapshot) {
@@ -376,6 +391,7 @@ async function* captureSnapshotResources(page, snapshot, options) {
 
   // wait for final network idle when not capturing DOM
   if (capture && snapshot.domSnapshot) {
+    yield waitForFontLoading(page);
     yield waitForDiscoveryNetworkIdle(page, discovery);
     yield* captureResponsiveAssets();
     capture(processSnapshotResources(snapshot));
@@ -389,7 +405,8 @@ export async function* discoverSnapshotResources(queue, options, callback) {
   let {
     snapshots,
     skipDiscovery,
-    dryRun
+    dryRun,
+    checkAndUpdateConcurrency
   } = options;
   yield* yieldAll(snapshots.reduce((all, snapshot) => {
     debugSnapshotOptions(snapshot);
@@ -403,6 +420,10 @@ export async function* discoverSnapshotResources(queue, options, callback) {
         callback(dryRun ? snap : processSnapshotResources(snap));
       }
     } else {
+      // update concurrency before pushing new job in discovery queue
+      // if case of monitoring is stopped due to in-activity,
+      // it can take upto 1 sec to execute this fun
+      checkAndUpdateConcurrency();
       all.push(queue.push(snapshot, callback));
     }
     return all;
@@ -490,6 +511,12 @@ export function createDiscoveryQueue(percy) {
               return resource;
             },
             saveResource: r => {
+              const limitResources = process.env.LIMIT_SNAPSHOT_RESOURCES || false;
+              const MAX_RESOURCES = Number(process.env.MAX_SNAPSHOT_RESOURCES) || 749;
+              if (limitResources && snapshot.resources.size >= MAX_RESOURCES) {
+                percy.log.debug(`Skipping resource ${r.url} — resource limit reached`);
+                return;
+              }
               snapshot.resources.set(r.url, r);
               if (!snapshot.discovery.disableCache) {
                 cache.set(r.url, r);

package/dist/install.js

@@ -162,13 +162,13 @@ export function chromium({
   });
 }
 
-// default chromium revisions corresponds to v123.0.6312.58
+// default chromium revisions corresponds to v126.0.6478.184
 chromium.revisions = {
-  linux: '1262506',
-  win64: '1262500',
-  win32: '1262500',
-  darwin: '1262506',
-  darwinArm: '1262509'
+  linux: '1300309',
+  win64: '1300297',
+  win32: '1300295',
+  darwin: '1300293',
+  darwinArm: '1300314'
 };
 
 // export the namespace by default

package/dist/network.js

@@ -491,6 +491,7 @@ async function makeDirectRequest(network, request, session) {
 
 // Save a resource from a request, skipping it if specific paramters are not met
 async function saveResponseResource(network, request, session) {
+  var _response$headers;
   let {
     disableCache,
     allowedHostnames,
@@ -504,6 +505,14 @@ async function saveResponseResource(network, request, session) {
     url,
     responseStatus: response === null || response === void 0 ? void 0 : response.status
   };
+  // Checing for content length more than 100MB, to prevent websocket error which is governed by
+  // maxPayload option of websocket defaulted to 100MB.
+  // If content-length is more than our allowed 25MB, no need to process that resouce we can return log.
+  let contentLength = (_response$headers = response.headers) === null || _response$headers === void 0 ? void 0 : _response$headers[Object.keys(response.headers).find(key => key.toLowerCase() === 'content-length')];
+  contentLength = parseInt(contentLength);
+  if (contentLength > MAX_RESOURCE_SIZE) {
+    return log.debug('- Skipping resource larger than 25MB', meta);
+  }
   let resource = network.intercept.getResource(url);
   if (!resource || !resource.root && !resource.provided && disableCache) {
     try {
@@ -521,6 +530,7 @@ async function saveResponseResource(network, request, session) {
       } else if (!body.length) {
         return log.debug('- Skipping empty response', meta);
       } else if (body.length > MAX_RESOURCE_SIZE) {
+        log.debug('- Missing headers for the requested resource.', meta);
         return log.debug('- Skipping resource larger than 25MB', meta);
       } else if (!ALLOWED_STATUSES.includes(response.status)) {
         return log.debug(`- Skipping disallowed status [${response.status}]`, meta);

package/dist/percy.js

@@ -17,9 +17,15 @@ import { base64encode, generatePromise, yieldAll, yieldTo, redactSecrets, detect
 import { createPercyServer, createStaticServer } from './api.js';
 import { gatherSnapshots, createSnapshotsQueue, validateSnapshotOptions } from './snapshot.js';
 import { discoverSnapshotResources, createDiscoveryQueue } from './discovery.js';
+import Monitoring from '@percy/monitoring';
 import { WaitForJob } from './wait-for-job.js';
 const MAX_SUGGESTION_CALLS = 10;
 
+// If no activity is done for 5 mins, we will stop monitoring
+// system metric eg: (cpu load && memory usage)
+const MONITOR_ACTIVITY_TIMEOUT = 300000;
+const MONITORING_INTERVAL_MS = 5000; // 5 sec
+
 // A Percy instance will create a new build when started, handle snapshot creation, asset discovery,
 // and resource uploads, and will finalize the build when stopped. Snapshots are processed
 // concurrently and the build is not finalized until all snapshots have been handled.
@@ -100,7 +106,13 @@ export class Percy {
     if (server) this.server = createPercyServer(this, port);
     this.browser = new Browser(this);
     _classPrivateFieldSet(_discovery, this, createDiscoveryQueue(this));
+    this.discoveryMaxConcurrency = _classPrivateFieldGet(_discovery, this).concurrency;
     _classPrivateFieldSet(_snapshots, this, createSnapshotsQueue(this));
+    this.monitoring = new Monitoring();
+    // used continue monitoring if there is activity going on
+    // if there is none, stop it
+    this.resetMonitoringId = null;
+    this.monitoringCheckLastExecutedAt = null;
 
     // generator methods are wrapped to autorun and return promises
     for (let m of ['start', 'stop', 'flush', 'idle', 'snapshot', 'upload']) {
@@ -109,6 +121,28 @@ export class Percy {
       this[m] = (...args) => generatePromise(method(...args));
     }
   }
+  systemMonitoringEnabled() {
+    return process.env.PERCY_DISABLE_SYSTEM_MONITORING !== 'true';
+  }
+  async configureSystemMonitor() {
+    await this.monitoring.startMonitoring({
+      interval: MONITORING_INTERVAL_MS
+    });
+    this.resetSystemMonitor();
+  }
+
+  // Debouncing logic to only stop Monitoring system
+  // if there is no any activity for 5 mins
+  // means, no job is pushed in queue from 5 mins
+  resetSystemMonitor() {
+    if (this.resetMonitoringId) {
+      clearTimeout(this.resetMonitoringId);
+      this.resetMonitoringId = null;
+    }
+    this.resetMonitoringId = setTimeout(() => {
+      this.monitoring.stopMonitoring();
+    }, MONITOR_ACTIVITY_TIMEOUT);
+  }
 
   // Shortcut for controlling the global logger's log level.
   loglevel(level) {
@@ -157,7 +191,7 @@ export class Percy {
       concurrency
     });
     _classPrivateFieldGet(_snapshots, this).set({
-      snapshotConcurrency
+      concurrency: snapshotConcurrency
     });
     return this.config;
   }
@@ -169,6 +203,12 @@ export class Percy {
     this.readyState = 0;
     this.cliStartTime = new Date().toISOString();
     try {
+      // started monitoring system metrics
+
+      if (this.systemMonitoringEnabled()) {
+        await this.configureSystemMonitor();
+        await this.monitoring.logSystemInfo();
+      }
       if (process.env.PERCY_CLIENT_ERROR_LOGS !== 'false') {
         this.log.warn('Notice: Percy collects CI logs to improve service and enhance your experience. These logs help us debug issues and provide insights on your dashboards, making it easier to optimize the product experience. Logs are stored securely for 30 days. You can opt out anytime with export PERCY_CLIENT_ERROR_LOGS=false, but keeping this enabled helps us offer the best support and features.');
       }
@@ -296,12 +336,66 @@ export class Percy {
       this.log.error(err);
       throw err;
     } finally {
+      // stop monitoring system metric, if not already stopped
+      this.monitoring.stopMonitoring();
+      clearTimeout(this.resetMonitoringId);
+
       // This issue doesn't comes under regular error logs,
       // it's detected if we just and stop percy server
       await this.checkForNoSnapshotCommandError();
       await this.sendBuildLogs();
     }
   }
+  checkAndUpdateConcurrency() {
+    // early exit if monitoring is disabled
+    if (!this.systemMonitoringEnabled()) return;
+
+    // early exit if asset discovery concurrency change is disabled
+    // NOTE: system monitoring will still be running as only concurrency
+    // change is disabled
+    if (process.env.PERCY_DISABLE_CONCURRENCY_CHANGE === 'true') return;
+
+    // start system monitoring if not already doing...
+    // this doesn't handle cases where there is suggest cpu spikes
+    // in less 1 sec range and if monitoring is not in running state
+    if (this.monitoringCheckLastExecutedAt && Date.now() - this.monitoringCheckLastExecutedAt < MONITORING_INTERVAL_MS) return;
+    if (!this.monitoring.running) this.configureSystemMonitor();else this.resetSystemMonitor();
+
+    // early return if last executed was less than 5 seconds
+    // as we will get the same cpu/mem info under 5 sec interval
+    const {
+      cpuInfo,
+      memoryUsageInfo
+    } = this.monitoring.getMonitoringInfo();
+    this.log.debug(`cpuInfo: ${JSON.stringify(cpuInfo)}`);
+    this.log.debug(`memoryInfo: ${JSON.stringify(memoryUsageInfo)}`);
+    if (cpuInfo.currentUsagePercent >= 80 || memoryUsageInfo.currentUsagePercent >= 80) {
+      let currentConcurrent = _classPrivateFieldGet(_discovery, this).concurrency;
+
+      // concurrency must be betweeen [1, (default/user defined value)]
+      let newConcurrency = Math.max(1, parseInt(currentConcurrent / 2));
+      newConcurrency = Math.min(this.discoveryMaxConcurrency, newConcurrency);
+      this.log.debug(`Downscaling discovery browser concurrency from ${_classPrivateFieldGet(_discovery, this).concurrency} to ${newConcurrency}`);
+      _classPrivateFieldGet(_discovery, this).set({
+        concurrency: newConcurrency
+      });
+    } else if (cpuInfo.currentUsagePercent <= 50 && memoryUsageInfo.currentUsagePercent <= 50) {
+      let currentConcurrent = _classPrivateFieldGet(_discovery, this).concurrency;
+      let newConcurrency = currentConcurrent + 2;
+
+      // concurrency must be betweeen [1, (default/user-defined value)]
+      newConcurrency = Math.min(this.discoveryMaxConcurrency, newConcurrency);
+      newConcurrency = Math.max(1, newConcurrency);
+      this.log.debug(`Upscaling discovery browser concurrency from ${_classPrivateFieldGet(_discovery, this).concurrency} to ${newConcurrency}`);
+      _classPrivateFieldGet(_discovery, this).set({
+        concurrency: newConcurrency
+      });
+    }
+
+    // reset timeout to stop monitoring after no-activity of 5 mins
+    this.resetSystemMonitor();
+    this.monitoringCheckLastExecutedAt = Date.now();
+  }
 
   // Takes one or more snapshots of a page while discovering resources to upload with the resulting
   // snapshots. Once asset discovery has completed for the provided snapshots, the queued task will
@@ -354,6 +448,7 @@ export class Percy {
         yield* discoverSnapshotResources(_classPrivateFieldGet(_discovery, this), {
           skipDiscovery: this.skipDiscovery,
           dryRun: this.dryRun,
+          checkAndUpdateConcurrency: this.checkAndUpdateConcurrency.bind(this),
           snapshots: yield* gatherSnapshots(options, {
             meta: {
               build: this.build

package/dist/queue.js

@@ -115,6 +115,13 @@ export class Queue {
     // return the deferred task promise
     return task.deferred;
   }
+  logQueueSize() {
+    this.log.debug(`${this.name} queueInfo: ${JSON.stringify({
+      queued: _classPrivateFieldGet(_queued, this).size,
+      pending: _classPrivateFieldGet(_pending, this).size,
+      total: _classPrivateFieldGet(_pending, this).size + _classPrivateFieldGet(_queued, this).size
+    })}`);
+  }
   // Cancels and aborts a specific item task.
   cancel(item) {
     let task = _assertClassBrand(_Queue_brand, this, _find).call(this, item);
@@ -243,6 +250,7 @@ export class Queue {
   // Repeatedly yields, calling the callback with the position of the task within the queue
 }
 function _dequeue() {
+  this.logQueueSize();
   if (!_classPrivateFieldGet(_queued, this).size || this.readyState < 2) return;
   if (_classPrivateFieldGet(_pending, this).size >= this.concurrency) return;
   let [task] = _classPrivateFieldGet(_queued, this);

package/dist/session.js

@@ -20,6 +20,12 @@ export class Session extends EventEmitter {
     this.on('Inspector.targetCrashed', this._handleTargetCrashed);
   }
   async close() {
+    var _this$browser;
+    // Check for the new closeBrowser option
+    if (((_this$browser = this.browser) === null || _this$browser === void 0 || (_this$browser = _this$browser.percy.config.discovery) === null || _this$browser === void 0 || (_this$browser = _this$browser.launchOptions) === null || _this$browser === void 0 ? void 0 : _this$browser.closeBrowser) === false) {
+      this.log.debug('Skipping session close due to closeBrowser:false option');
+      return true;
+    }
     if (!this.browser || this.closing) return;
     this.closing = true;
     await this.browser.send('Target.closeTarget', {

package/dist/snapshot.js

@@ -3,7 +3,7 @@ import PercyConfig from '@percy/config';
 import micromatch from 'micromatch';
 import { configSchema } from './config.js';
 import Queue from './queue.js';
-import { request, hostnameMatches, yieldTo, snapshotLogName, decodeAndEncodeURLWithLogging, compareObjectTypes } from './utils.js';
+import { request, hostnameMatches, yieldTo, snapshotLogName, decodeAndEncodeURLWithLogging, compareObjectTypes, normalizeOptions } from './utils.js';
 import { JobData } from './wait-for-job.js';
 
 // Throw a better error message for missing or invalid urls
@@ -151,14 +151,17 @@ function getSnapshotOptions(options, {
       captureMockedServiceWorker: config.discovery.captureMockedServiceWorker,
       captureSrcset: config.discovery.captureSrcset,
       userAgent: config.discovery.userAgent,
-      retry: config.discovery.retry
+      retry: config.discovery.retry,
+      scrollToBottom: config.discovery.scrollToBottom
     }
   }, options], (path, prev, next) => {
-    var _next, _next2;
+    var _next, _next2, _next3;
     switch (path.map(k => k.toString()).join('.')) {
       case 'widths':
         // dedup, sort, and override widths when not empty
         return [path, !((_next = next) !== null && _next !== void 0 && _next.length) ? prev : [...new Set(next)].sort((a, b) => a - b)];
+      case 'browsers':
+        return [path, !((_next2 = next) !== null && _next2 !== void 0 && _next2.length) ? prev : [...new Set(next)]];
       case 'percyCSS':
         // concatenate percy css
         return [path, [prev, next].filter(Boolean).join('\n')];
@@ -167,7 +170,7 @@ function getSnapshotOptions(options, {
         return Array.isArray(next) || typeof next !== 'object' ? [path.concat('beforeSnapshot'), next] : [path];
       case 'discovery.disallowedHostnames':
         // prevent disallowing the root hostname
-        return [path, !((_next2 = next) !== null && _next2 !== void 0 && _next2.length) ? prev : (prev ?? []).concat(next).filter(h => !hostnameMatches(h, options.url))];
+        return [path, !((_next3 = next) !== null && _next3 !== void 0 && _next3.length) ? prev : (prev ?? []).concat(next).filter(h => !hostnameMatches(h, options.url))];
     }
 
     // ensure additional snapshots have complete names
@@ -192,9 +195,9 @@ function getSnapshotOptions(options, {
 export function validateSnapshotOptions(options) {
   var _migrated$baseUrl, _migrated$domSnapshot;
   let log = logger('core:snapshot');
-
   // decide which schema to validate against
   let schema = ['domSnapshot', 'dom-snapshot', 'dom_snapshot'].some(k => k in options) && '/snapshot/dom' || 'url' in options && '/snapshot' || 'sitemap' in options && '/snapshot/sitemap' || 'serve' in options && '/snapshot/server' || 'snapshots' in options && '/snapshot/list' || '/snapshot';
+  options = normalizeOptions(options);
   let {
     // normalize, migrate, and remove certain properties from validating
     clientInfo,
@@ -226,7 +229,6 @@ export function validateSnapshotOptions(options) {
     log.warn('Encountered snapshot serialization warnings:');
     for (let w of domWarnings) log.warn(`- ${w}`);
   }
-
   // warn on validation errors
   let errors = PercyConfig.validate(migrated, schema);
   if ((errors === null || errors === void 0 ? void 0 : errors.length) > 0) {

package/dist/utils.js

@@ -52,6 +52,9 @@ export function percyAutomateRequestHandler(req, percy) {
     ignoreRegionXpaths: (_percy$config$snapsho4 = percy.config.snapshot.ignoreRegions) === null || _percy$config$snapsho4 === void 0 ? void 0 : _percy$config$snapsho4.ignoreRegionXpaths,
     considerRegionSelectors: (_percy$config$snapsho5 = percy.config.snapshot.considerRegions) === null || _percy$config$snapsho5 === void 0 ? void 0 : _percy$config$snapsho5.considerRegionSelectors,
     considerRegionXpaths: (_percy$config$snapsho6 = percy.config.snapshot.considerRegions) === null || _percy$config$snapsho6 === void 0 ? void 0 : _percy$config$snapsho6.considerRegionXpaths,
+    regions: percy.config.snapshot.regions,
+    algorithm: percy.config.snapshot.algorithm,
+    algorithmConfiguration: percy.config.snapshot.algorithmConfiguration,
     sync: percy.config.snapshot.sync,
     version: 'v2'
   }, camelCasedOptions], (path, prev, next) => {
@@ -389,6 +392,20 @@ export function redactSecrets(data) {
 export function base64encode(content) {
   return Buffer.from(content).toString('base64');
 }
+
+// It checks if content is already gzipped or not.
+// We don't want to gzip already gzipped content.
+export function isGzipped(content) {
+  if (!(content instanceof Uint8Array || content instanceof ArrayBuffer)) {
+    return false;
+  }
+
+  // Ensure content is a Uint8Array
+  const data = content instanceof ArrayBuffer ? new Uint8Array(content) : content;
+
+  // Gzip magic number: 0x1f8b
+  return data.length > 2 && data[0] === 0x1f && data[1] === 0x8b;
+}
 const RESERVED_CHARACTERS = {
   '%3A': ':',
   '%23': '#',
@@ -526,4 +543,37 @@ export function compareObjectTypes(obj1, obj2) {
     if (!keys2.includes(key) || !compareObjectTypes(obj1[key], obj2[key])) return false;
   }
   return true;
+}
+const OPTION_MAPPINGS = {
+  name: 'name',
+  widths: 'widths',
+  scope: 'scope',
+  scopeoptions: 'scopeOptions',
+  minheight: 'minHeight',
+  enablejavascript: 'enableJavaScript',
+  enablelayout: 'enableLayout',
+  clientinfo: 'clientInfo',
+  environmentinfo: 'environmentInfo',
+  sync: 'sync',
+  testcase: 'testCase',
+  labels: 'labels',
+  thtestcaseexecutionid: 'thTestCaseExecutionId',
+  browsers: 'browsers',
+  resources: 'resources',
+  meta: 'meta',
+  snapshot: 'snapshot'
+};
+export function normalizeOptions(options) {
+  const normalizedOptions = {};
+  for (const key in options) {
+    const lowerCaseKey = key.toLowerCase().replace(/[-_]/g, '');
+    const normalizedKey = OPTION_MAPPINGS[lowerCaseKey] ? OPTION_MAPPINGS[lowerCaseKey] : key;
+    normalizedOptions[normalizedKey] = options[key];
+  }
+  return normalizedOptions;
+}
+export async function* maybeScrollToBottom(page, discovery) {
+  if (discovery.scrollToBottom && page.enableJavaScript) {
+    yield page.eval('await scrollToBottom()');
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/core",
-  "version": "1.31.0-alpha.2",
+  "version": "1.31.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -9,7 +9,7 @@
   },
   "publishConfig": {
     "access": "public",
-    "tag": "alpha"
+    "tag": "latest"
   },
   "engines": {
     "node": ">=14"
@@ -43,11 +43,12 @@
     "test:types": "tsd"
   },
   "dependencies": {
-    "@percy/client": "1.31.0-alpha.2",
-    "@percy/config": "1.31.0-alpha.2",
-    "@percy/dom": "1.31.0-alpha.2",
-    "@percy/logger": "1.31.0-alpha.2",
-    "@percy/webdriver-utils": "1.31.0-alpha.2",
+    "@percy/client": "1.31.0",
+    "@percy/config": "1.31.0",
+    "@percy/dom": "1.31.0",
+    "@percy/logger": "1.31.0",
+    "@percy/monitoring": "1.31.0",
+    "@percy/webdriver-utils": "1.31.0",
     "content-disposition": "^0.5.4",
     "cross-spawn": "^7.0.3",
     "extract-zip": "^2.0.1",
@@ -60,5 +61,5 @@
     "ws": "^8.17.1",
     "yaml": "^2.4.1"
   },
-  "gitHead": "1c7711f564fd4a112e1e1490a772db757df0535d"
+  "gitHead": "49895470c0dfa7242881db43e293317d1fb8f8b6"
 }

package/test/helpers/server.js

@@ -1,18 +1,25 @@
 // aliased to src during tests
 import Server from '../../dist/server.js';
 
-export function createTestServer({ default: defaultReply, ...replies }, port = 8000) {
+export function createTestServer({ default: defaultReply, ...replies }, port = 8000, options = {}) {
   let server = new Server();
 
   // alternate route handling
-  let handleReply = reply => async (req, res) => {
+  let handleReply = (reply, options = {}) => async (req, res) => {
     let [status, headers, body] = typeof reply === 'function' ? await reply(req) : reply;
     if (!Buffer.isBuffer(body) && typeof body !== 'string') body = JSON.stringify(body);
+
+    if (options.noHeaders) {
+      return res.writeHead(status).end(body);
+    }
+    if (options.headersOverride) {
+      headers = { ...headers, ...options.headersOverride };
+    }
     return res.send(status, headers, body);
   };
 
   // map replies to alternate route handlers
-  server.reply = (p, reply) => (replies[p] = handleReply(reply), null);
+  server.reply = (p, reply, options = {}) => (replies[p] = handleReply(reply, options), null);
   for (let [p, reply] of Object.entries(replies)) server.reply(p, reply);
   if (defaultReply) defaultReply = handleReply(defaultReply);
 

package/types/index.d.ts

@@ -57,6 +57,7 @@ interface CommonSnapshotOptions {
   reshuffleInvalidTags?: boolean;
   devicePixelRatio?: number;
   scopeOptions?: ScopeOptions;
+  browsers?: string[];
 }
 
 export interface SnapshotOptions extends CommonSnapshotOptions {