@applitools/core 4.63.0 → 4.64.0

package/CHANGELOG.md

@@ -1,5 +1,181 @@
 # Changelog
 
+## [4.64.0](https://github.com/Applitools-Dev/sdk/compare/js/core@4.63.1...js/core@4.64.0) (2026-06-04)
+
+
+### Features
+
+* auto-accept UFG diffs from infra updates | AD-9583 ([#3797](https://github.com/Applitools-Dev/sdk/issues/3797)) ([fde553c](https://github.com/Applitools-Dev/sdk/commit/fde553c947aa3c040660ef5d07855fa4a1412399))
+* support default match level from renderinfo | AD-13499 ([#3799](https://github.com/Applitools-Dev/sdk/issues/3799)) ([c7e8aeb](https://github.com/Applitools-Dev/sdk/commit/c7e8aeb3f231d9b4e6e368d7ae5f87115c5cad09))
+
+
+### Bug Fixes
+
+* source hideCaret from settings.hideCaret in NML classic capture | AD-14053 ([#3878](https://github.com/Applitools-Dev/sdk/issues/3878)) ([f07b4f5](https://github.com/Applitools-Dev/sdk/commit/f07b4f5c90bb9b7de0300cef93f23dc833268a7c))
+
+
+### Dependencies
+
+* @applitools/nml-client bumped to 1.11.29
+
+* @applitools/core-base bumped to 1.35.0
+  #### Features
+
+  * auto-accept UFG diffs from infra updates | AD-9583 ([#3797](https://github.com/Applitools-Dev/sdk/issues/3797)) ([fde553c](https://github.com/Applitools-Dev/sdk/commit/fde553c947aa3c040660ef5d07855fa4a1412399))
+* @applitools/ec-client bumped to 1.12.31
+
+
+## [4.63.1](https://github.com/Applitools-Dev/sdk/compare/js/core@4.63.0...js/core@4.63.1) (2026-05-26)
+
+
+### Bug Fixes
+
+* prevent BrightCove/video.js player corruption during layoutBreakpoints snapshots ([#3828](https://github.com/Applitools-Dev/sdk/issues/3828)) ([380fbae](https://github.com/Applitools-Dev/sdk/commit/380fbaeb1c6a964c640975f1a109417db51f691c))
+* strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+* truly disable NML broker URL cache between checks | FLD-4283 ([#3837](https://github.com/Applitools-Dev/sdk/issues/3837)) ([da76dd3](https://github.com/Applitools-Dev/sdk/commit/da76dd3227c3297320be0d19558a7437b5733999))
+
+
+### Dependencies
+
+* @applitools/utils bumped to 1.14.5
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+* @applitools/logger bumped to 2.2.12
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/dom-shared bumped to 1.2.1
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+* @applitools/dom-snapshot bumped to 4.17.2
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/socket bumped to 1.3.13
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/req bumped to 1.10.2
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/image bumped to 1.2.11
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/snippets bumped to 2.9.2
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/dom-capture bumped to 11.8.1
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/driver bumped to 1.26.2
+  #### Bug Fixes
+
+  * redact cookie values from logs to prevent sensitive data exposure | AD-12834 ([#3835](https://github.com/Applitools-Dev/sdk/issues/3835)) ([d883647](https://github.com/Applitools-Dev/sdk/commit/d883647d8e007467bd2770ddb79f89be057067b9))
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/spec-driver-webdriver bumped to 1.6.2
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/spec-driver-selenium bumped to 1.8.2
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/spec-driver-playwright bumped to 1.9.2
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/spec-driver-puppeteer bumped to 1.8.2
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/screenshoter bumped to 3.12.21
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/nml-client bumped to 1.11.28
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/tunnel-client bumped to 1.11.14
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/ufg-client bumped to 1.22.2
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+  * strip extra fields from checkResources log output ([#3836](https://github.com/Applitools-Dev/sdk/issues/3836)) ([6d75209](https://github.com/Applitools-Dev/sdk/commit/6d752094abb6fcc0e998cf95e1f266964dbfd6f3))
+
+
+
+* @applitools/core-base bumped to 1.34.1
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/ec-client bumped to 1.12.30
+  #### Bug Fixes
+
+  * strip .d.ts extension from import() type specifiers | FLD-4429 ([#3830](https://github.com/Applitools-Dev/sdk/issues/3830)) ([37aac45](https://github.com/Applitools-Dev/sdk/commit/37aac45958b713702bea87c144623dd3e65fce79))
+
+
+
+* @applitools/test-server bumped to 1.4.4
+
+
 ## [4.63.0](https://github.com/Applitools-Dev/sdk/compare/js/core@4.62.0...js/core@4.63.0) (2026-05-19)
 
 

package/dist/automation/get-nml-client.js

@@ -4,15 +4,17 @@ exports.makeGetNMLClient = exports.clearNMLClients = void 0;
 const nml_client_1 = require("@applitools/nml-client");
 const utils_1 = require("@applitools/utils");
 const clients = new Map();
+const cacheDisabled = new Set();
 // for tests
 function clearNMLClients() {
     clients.clear();
+    cacheDisabled.clear();
 }
 exports.clearNMLClients = clearNMLClients;
 function makeGetNMLClient({ client, logger: mainLogger }) {
     return {
         getNMLClient,
-        clearNMLClientCache,
+        disableNMLClientCache,
     };
     async function getNMLClient({ driver, settings, logger, }) {
         if (client)
@@ -20,26 +22,30 @@ function makeGetNMLClient({ client, logger: mainLogger }) {
         logger = logger.extend(mainLogger);
         const { sessionId } = await driver.getDriverInfo();
         const cacheKey = sessionId !== null && sessionId !== void 0 ? sessionId : driver.guid;
-        const clientFromCache = clients.get(cacheKey);
-        if (clientFromCache) {
-            return clientFromCache;
+        if (cacheDisabled.has(cacheKey)) {
+            logger.log('NML broker url cache is disabled for this session — re-extracting broker url');
         }
         else {
-            const brokerUrl = await driver.extractBrokerUrl();
-            if (!brokerUrl)
-                throw new Error('Unable to extract broker url from the device');
-            if (utils_1.types.has(brokerUrl, 'error')) {
-                logger.error('Broker url extraction has failed with error', brokerUrl.error);
-                throw new Error(brokerUrl.error);
-            }
-            const nmlClient = (0, nml_client_1.makeNMLClient)({ settings: { brokerUrl, ...settings }, logger });
-            clients.set(cacheKey, nmlClient);
-            return nmlClient;
+            const clientFromCache = clients.get(cacheKey);
+            if (clientFromCache)
+                return clientFromCache;
+        }
+        const brokerUrl = await driver.extractBrokerUrl();
+        if (!brokerUrl)
+            throw new Error('Unable to extract broker url from the device');
+        if (utils_1.types.has(brokerUrl, 'error')) {
+            logger.error('Broker url extraction has failed with error', brokerUrl.error);
+            throw new Error(brokerUrl.error);
         }
+        const nmlClient = (0, nml_client_1.makeNMLClient)({ settings: { brokerUrl, ...settings }, logger });
+        if (!cacheDisabled.has(cacheKey))
+            clients.set(cacheKey, nmlClient);
+        return nmlClient;
     }
-    async function clearNMLClientCache(driver) {
+    async function disableNMLClientCache(driver) {
         const { sessionId } = await driver.getDriverInfo();
         const cacheKey = sessionId !== null && sessionId !== void 0 ? sessionId : driver.guid;
+        cacheDisabled.add(cacheKey);
         clients.delete(cacheKey);
     }
 }

package/dist/check.js

@@ -35,8 +35,8 @@ const chalk_1 = __importDefault(require("chalk"));
 function makeCheck({ type: defaultType = 'classic', eyes, target: defaultTarget, spec, logger: mainLogger, }) {
     let stepIndex = 0;
     return async function check({ type = defaultType, target = defaultTarget, settings, config, logger = mainLogger, } = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
-        var _s, _t, _u, _v, _w;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        var _t, _u, _v, _w, _x;
         logger = logger.extend(mainLogger, { tags: [`check-${type}-${utils.general.shortid()}`] });
         settings = { ...config === null || config === void 0 ? void 0 : config.screenshot, ...config === null || config === void 0 ? void 0 : config.check, ...settings };
         (_a = settings.fully) !== null && _a !== void 0 ? _a : (settings.fully = !settings.region && (!settings.frames || settings.frames.length === 0));
@@ -44,9 +44,9 @@ function makeCheck({ type: defaultType = 'classic', eyes, target: defaultTarget,
         (_c = settings.hideScrollbars) !== null && _c !== void 0 ? _c : (settings.hideScrollbars = true);
         (_d = settings.hideCaret) !== null && _d !== void 0 ? _d : (settings.hideCaret = true);
         settings.overlap = { top: 10, bottom: 50, ...settings === null || settings === void 0 ? void 0 : settings.overlap };
-        (_e = settings.matchLevel) !== null && _e !== void 0 ? _e : (settings.matchLevel = 'Strict');
-        (_f = settings.ignoreCaret) !== null && _f !== void 0 ? _f : (settings.ignoreCaret = true);
-        (_g = settings.sendDom) !== null && _g !== void 0 ? _g : (settings.sendDom = eyes.test.account.rcaEnabled ||
+        (_e = settings.matchLevel) !== null && _e !== void 0 ? _e : (settings.matchLevel = (_f = eyes.test.account.defaultMatchLevel) !== null && _f !== void 0 ? _f : 'Strict');
+        (_g = settings.ignoreCaret) !== null && _g !== void 0 ? _g : (settings.ignoreCaret = true);
+        (_h = settings.sendDom) !== null && _h !== void 0 ? _h : (settings.sendDom = eyes.test.account.rcaEnabled ||
             settings.matchLevel === 'Layout' ||
             settings.matchLevel === 'Dynamic' ||
             settings.enablePatterns ||
@@ -54,26 +54,27 @@ function makeCheck({ type: defaultType = 'classic', eyes, target: defaultTarget,
             !utils.types.isEmpty(settings.dynamicRegions) ||
             !utils.types.isEmpty(settings.layoutRegions) ||
             !utils.types.isEmpty(settings.accessibilitySettings));
-        (_h = settings.autProxy) !== null && _h !== void 0 ? _h : (settings.autProxy = eyes.test.eyesServer.proxy);
-        (_j = settings.useDom) !== null && _j !== void 0 ? _j : (settings.useDom = false);
-        (_k = (_s = settings).matchTimeout) !== null && _k !== void 0 ? _k : (_s.matchTimeout = 0);
+        (_j = settings.autProxy) !== null && _j !== void 0 ? _j : (settings.autProxy = eyes.test.eyesServer.proxy);
+        (_k = settings.useDom) !== null && _k !== void 0 ? _k : (settings.useDom = settings.sendDom // if we send the dom, it just makes sense to use it (unless the user turned it off)
+        );
+        (_l = (_t = settings).matchTimeout) !== null && _l !== void 0 ? _l : (_t.matchTimeout = 0);
         settings.lazyLoad = settings.lazyLoad === true ? {} : settings.lazyLoad;
         if (settings.lazyLoad) {
-            (_l = (_t = settings.lazyLoad).scrollLength) !== null && _l !== void 0 ? _l : (_t.scrollLength = defaults_1.DEFAULT_LAZY_LOAD.scrollLength);
-            (_m = (_u = settings.lazyLoad).waitingTime) !== null && _m !== void 0 ? _m : (_u.waitingTime = defaults_1.DEFAULT_LAZY_LOAD.waitingTime);
-            (_o = (_v = settings.lazyLoad).maxAmountToScroll) !== null && _o !== void 0 ? _o : (_v.maxAmountToScroll = defaults_1.DEFAULT_LAZY_LOAD.maxAmountToScroll);
+            (_m = (_u = settings.lazyLoad).scrollLength) !== null && _m !== void 0 ? _m : (_u.scrollLength = defaults_1.DEFAULT_LAZY_LOAD.scrollLength);
+            (_o = (_v = settings.lazyLoad).waitingTime) !== null && _o !== void 0 ? _o : (_v.waitingTime = defaults_1.DEFAULT_LAZY_LOAD.waitingTime);
+            (_p = (_w = settings.lazyLoad).maxAmountToScroll) !== null && _p !== void 0 ? _p : (_w.maxAmountToScroll = defaults_1.DEFAULT_LAZY_LOAD.maxAmountToScroll);
         }
         settings.stepIndex = stepIndex++;
-        (_p = settings.waitBetweenStitches) !== null && _p !== void 0 ? _p : (settings.waitBetweenStitches = utils.types.isObject(settings.lazyLoad)
+        (_q = settings.waitBetweenStitches) !== null && _q !== void 0 ? _q : (settings.waitBetweenStitches = utils.types.isObject(settings.lazyLoad)
             ? settings.lazyLoad.waitingTime
             : defaults_1.DEFAULT_WAIT_BEFORE_CAPTURE);
         if (settings.mobileOptions) {
-            (_q = (_w = settings.mobileOptions).keepNavigationBar) !== null && _q !== void 0 ? _q : (_w.keepNavigationBar = false);
+            (_r = (_x = settings.mobileOptions).keepNavigationBar) !== null && _r !== void 0 ? _r : (_x.keepNavigationBar = false);
         }
         if (settings.matchLevel === 'Content') {
             logger.console.log(chalk_1.default.yellow(lang.matchLevelContentDeprecatedWarning));
         }
-        if ((_r = settings.usedDeprecations) === null || _r === void 0 ? void 0 : _r.length) {
+        if ((_s = settings.usedDeprecations) === null || _s === void 0 ? void 0 : _s.length) {
             void eyes.core.logEvent({
                 settings: {
                     ...eyes.test.eyesServer,

package/dist/classic/check-and-close.js

@@ -136,7 +136,7 @@ function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultE
                         fully: settings.fully,
                         stitchMode: settings.stitchMode,
                         hideScrollbars: settings.hideScrollbars,
-                        hideCaret: settings.hideScrollbars,
+                        hideCaret: settings.hideCaret,
                         overlap: settings.overlap,
                         waitBeforeCapture: settings.waitBeforeCapture,
                         waitBetweenStitches: settings.waitBetweenStitches,

package/dist/classic/check.js

@@ -347,7 +347,7 @@ async function takeNMLScreenshot({ driver, settings, environments, logger, eyes,
             fully: settings.fully,
             stitchMode: settings.stitchMode,
             hideScrollbars: settings.hideScrollbars,
-            hideCaret: settings.hideScrollbars,
+            hideCaret: settings.hideCaret,
             overlap: settings.overlap,
             waitBeforeCapture: settings.waitBeforeCapture,
             waitBetweenStitches: settings.waitBetweenStitches,

package/dist/open-eyes.js

@@ -145,7 +145,7 @@ function makeOpenEyes({ type: defaultType = 'classic', clients, batch, removeDup
             logger,
         });
         if (settings.disableBrokerUrlCache && driver) {
-            await core.clearNMLClientCache(driver);
+            await core.disableNMLClientCache(driver);
         }
         const getTypedEyes = (0, get_typed_eyes_1.makeGetTypedEyes)({
             type,

package/dist/ufg/check.js

@@ -37,6 +37,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const take_snapshots_1 = require("./take-snapshots");
 const create_render_target_from_snapshot_1 = require("./create-render-target-from-snapshot");
 const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
+const to_old_infra_environment_1 = require("./to-old-infra-environment");
 function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironments = [], spec, signal, logger: mainLogger, }) {
     return async function check({ target = defaultTarget, settings = {}, logger = mainLogger, } = {}) {
         var _a;
@@ -73,7 +74,7 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
             snapshots = !utils.types.isArray(target) ? Array(uniqueEnvironments.length).fill(target) : target;
         }
         const promises = snapshots.map(async (snapshot, i) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            var _a, _b, _c, _d, _e, _f, _g, _h;
             const environmentLogger = logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
             const { target } = snapshot;
             const environment = uniqueEnvironments[i];
@@ -116,39 +117,44 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                     const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
                         settings: snapshot.settings,
                     });
-                    const { renderId, selectorRegions, ...baseTarget } = await ufgClient.render({
-                        target: renderTarget,
-                        settings: {
-                            ...snapshot.settings,
-                            region: (_e = selectors.target) !== null && _e !== void 0 ? _e : snapshot.settings.region,
-                            scrollRootElement: selectors.scrolling,
-                            selectorsToCalculate: selectors.calculate,
-                            includeFullPageSize: Boolean(snapshot.settings.pageId),
-                            environment: { ...environment, environmentId: baseEyes.test.environment.environmentId },
-                            uploadUrl: baseEyes.test.uploadUrl,
-                            stitchingServiceUrl: baseEyes.test.stitchingServiceUrl,
-                        },
-                        signal,
-                        logger: environmentLogger,
-                    });
-                    const baseSettings = getBaseCheckSettings({
-                        calculatedRegions: selectors.calculate.map((_, index) => {
-                            var _a;
-                            return ({
-                                regions: (_a = selectorRegions === null || selectorRegions === void 0 ? void 0 : selectorRegions[index]) !== null && _a !== void 0 ? _a : [],
-                            });
-                        }),
-                    });
-                    baseSettings.renderId = renderId;
-                    baseTarget.source = snapshot.url;
-                    baseTarget.name = snapshot.title;
+                    const renderForCheck = async (env) => {
+                        var _a;
+                        const { renderId, selectorRegions, ...target } = await ufgClient.render({
+                            target: renderTarget,
+                            settings: {
+                                ...snapshot.settings,
+                                region: (_a = selectors.target) !== null && _a !== void 0 ? _a : snapshot.settings.region,
+                                scrollRootElement: selectors.scrolling,
+                                selectorsToCalculate: selectors.calculate,
+                                includeFullPageSize: Boolean(snapshot.settings.pageId),
+                                environment: { ...env, environmentId: baseEyes.test.environment.environmentId },
+                                uploadUrl: baseEyes.test.uploadUrl,
+                                stitchingServiceUrl: baseEyes.test.stitchingServiceUrl,
+                            },
+                            signal,
+                            logger: environmentLogger,
+                        });
+                        const checkSettings = getBaseCheckSettings({
+                            calculatedRegions: selectors.calculate.map((_, index) => {
+                                var _a;
+                                return ({
+                                    regions: (_a = selectorRegions === null || selectorRegions === void 0 ? void 0 : selectorRegions[index]) !== null && _a !== void 0 ? _a : [],
+                                });
+                            }),
+                        });
+                        checkSettings.renderId = renderId;
+                        target.source = snapshot.url;
+                        target.name = snapshot.title;
+                        return { target, settings: checkSettings };
+                    };
+                    const { target: baseTarget, settings: baseSettings } = await renderForCheck(environment);
                     if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                         environmentLogger.warn('Command "check" was aborted after rendering');
                         throw new abort_error_1.AbortError('Command "check" was aborted after rendering');
                     }
                     else if (!baseEyes.running) {
-                        environmentLogger.warn(`Render on environment with id "${(_f = baseEyes.test.environment) === null || _f === void 0 ? void 0 : _f.environmentId}" was aborted during one of the previous steps`);
-                        throw new abort_error_1.AbortError(`Render on environment with id "${(_g = baseEyes.test.environment) === null || _g === void 0 ? void 0 : _g.environmentId}" was aborted during one of the previous steps`);
+                        environmentLogger.warn(`Render on environment with id "${(_e = baseEyes.test.environment) === null || _e === void 0 ? void 0 : _e.environmentId}" was aborted during one of the previous steps`);
+                        throw new abort_error_1.AbortError(`Render on environment with id "${(_f = baseEyes.test.environment) === null || _f === void 0 ? void 0 : _f.environmentId}" was aborted during one of the previous steps`);
                     }
                     if (settings.assumesMutability) {
                         void eyes.core.logEvent({
@@ -166,7 +172,7 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                                         userTestId: baseEyes.test.userTestId,
                                         appId: baseEyes.test.appId,
                                         baselineId: baseEyes.test.baselineId,
-                                        environmentId: (_h = baseEyes.test.environment) === null || _h === void 0 ? void 0 : _h.environmentId,
+                                        environmentId: (_g = baseEyes.test.environment) === null || _g === void 0 ? void 0 : _g.environmentId,
                                     },
                                     isNew: baseEyes.test.isNew,
                                     resultsUrl: baseEyes.test.resultsUrl,
@@ -182,14 +188,35 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                     catch (err) {
                         logger.log('Failed to log invalid check settings', err);
                     }
-                    await baseEyes.check({
+                    const checkResult = await baseEyes.check({
                         target: { ...baseTarget, isTransformed: true },
                         settings: baseSettings,
                         logger: environmentLogger,
                     });
+                    if (!checkResult.asExpected && baseEyes.test.shouldRetryWithOldInfra) {
+                        const oldInfraEnvironment = (0, to_old_infra_environment_1.toOldInfraEnvironment)(environment);
+                        if (oldInfraEnvironment) {
+                            // Best-effort: the retry adds an extra render + check, and a transient
+                            // failure there (old browser version unavailable, render timeout, 5xx)
+                            // must not abort the environment — the primary check already recorded
+                            // its step. Swallow and log so the retry can only ever help.
+                            try {
+                                const { target, settings } = await renderForCheck(oldInfraEnvironment);
+                                settings.oldInfraRetry = true;
+                                await baseEyes.check({
+                                    target: { ...target, isTransformed: true },
+                                    settings,
+                                    logger: environmentLogger,
+                                });
+                            }
+                            catch (error) {
+                                environmentLogger.warn('Old-infra retry failed; keeping the primary check result', error);
+                            }
+                        }
+                    }
                 }
                 catch (error) {
-                    environmentLogger.error(`Render on environment with id "${(_j = baseEyes.test.environment) === null || _j === void 0 ? void 0 : _j.environmentId}" failed due to an error`, error);
+                    environmentLogger.error(`Render on environment with id "${(_h = baseEyes.test.environment) === null || _h === void 0 ? void 0 : _h.environmentId}" failed due to an error`, error);
                     if (baseEyes.running && !(signal === null || signal === void 0 ? void 0 : signal.aborted))
                         await baseEyes.abort({ logger: environmentLogger, settings: { reason: error } });
                 }

package/dist/ufg/to-old-infra-environment.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOldInfraEnvironment = void 0;
+const latestToOneBack = {
+    chrome: 'chrome-one-version-back',
+    firefox: 'firefox-one-version-back',
+    safari: 'safari-one-version-back',
+    edgechromium: 'edgechromium-one-version-back',
+};
+/**
+ * Returns the same UFG environment retargeted at the previous browser/OS version,
+ * or `null` if the input is not at a latest-alias environment (already one-version-back,
+ * pinned to a specific version, or an unsupported browser).
+ */
+function toOldInfraEnvironment(env) {
+    if (!isLatest(env))
+        return null;
+    if ('iosDeviceInfo' in env)
+        return { ...env, iosDeviceInfo: { ...env.iosDeviceInfo, version: 'latest-1' } };
+    if ('androidDeviceInfo' in env)
+        return { ...env, androidDeviceInfo: { ...env.androidDeviceInfo, version: 'latest-1' } };
+    if ('chromeEmulationInfo' in env)
+        return { ...env, name: 'chrome-one-version-back' };
+    return { ...env, name: latestToOneBack[env.name] };
+}
+exports.toOldInfraEnvironment = toOldInfraEnvironment;
+function isLatest(env) {
+    if ('iosDeviceInfo' in env)
+        return env.iosDeviceInfo.version !== 'latest-1';
+    if ('androidDeviceInfo' in env)
+        return env.androidDeviceInfo.version !== 'latest-1';
+    if ('chromeEmulationInfo' in env)
+        return !env.name || env.name === 'chrome';
+    return !!env.name && env.name in latestToOneBack;
+}

package/dist/ufg/utils/media-playback-guard.js

@@ -0,0 +1,382 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pagePayload = exports.makeMediaPlaybackGuard = void 0;
+/**
+ * Prevents media playback side-effects during the layoutBreakpoints snapshot loop.
+ *
+ * dom-snapshot calls video.play() per breakpoint to capture a video frame. For
+ * BrightCove / video.js players this triggers CSS class changes (has-started, is-playing)
+ * and subtitle text injection that outlast the corresponding pause() call. With multiple
+ * breakpoints the mutations accumulate and corrupt visual snapshots.
+ *
+ * Lifecycle:
+ *   const guard = makeMediaPlaybackGuard({context, logger})
+ *   await guard.setup()                          // once, before the loop
+ *   for (const entry of entries) {
+ *     await guard.beforeResize()                 // before setViewportSize
+ *     // setViewportSize / reload / lazyLoad
+ *     await guard.beforeSnapshot()               // after resize, before takeDomSnapshot
+ *     // takeDomSnapshot
+ *     await guard.afterSnapshot()                // after takeDomSnapshot
+ *   }
+ *   // setViewportSize (restore)
+ *   await guard.teardown()                       // once, after final viewport restore
+ *
+ * Implementation notes:
+ *
+ * The TypeScript layer is just orchestration — `setup` / `beforeResize` / etc. each
+ * dispatch a phase name to a single self-contained page-side payload (`pagePayload`
+ * below) via `context.execute`. The first call installs a library at `window[ns]`
+ * with one handler per lifecycle method; subsequent calls just look up and run
+ * `window[ns][phase]()`. Teardown deletes `window[ns]` so a fresh guard starts clean.
+ *
+ *   - `ns` is randomised per guard instance so concurrent guards on the same page
+ *     (e.g. nested checks) do not collide.
+ *   - Per-element state lives in a `WeakMap`, not on the elements themselves — no
+ *     marker properties leak onto the page's DOM.
+ *   - A single `walkAll(root, fn)` helper handles every Document/ShadowRoot traversal.
+ *   - A `MutationObserver` covers the gap between phase calls (e.g. videos that
+ *     BrightCove creates during setViewportSize). The synchronous walks in
+ *     `beforeSnapshot` remain because the observer fires on a microtask and would
+ *     otherwise lose the race against dom-snapshot's serialization.
+ */
+function makeMediaPlaybackGuard({ context, logger, }) {
+    const ns = '__applitools_mpg_' + Math.random().toString(36).slice(2) + '__';
+    return {
+        setup: () => runPhase('setup'),
+        beforeResize: () => runPhase('beforeResize'),
+        beforeSnapshot: () => runPhase('beforeSnapshot'),
+        afterSnapshot: () => runPhase('afterSnapshot'),
+        teardown: () => runPhase('teardown'),
+    };
+    function runPhase(phase) {
+        return context
+            .execute(pagePayload, { ns, phase })
+            .catch((err) => logger.warn(`media guard: ${phase} failed`, err));
+    }
+}
+exports.makeMediaPlaybackGuard = makeMediaPlaybackGuard;
+/**
+ * The entire page-side library — a single self-contained function shipped to the
+ * browser by `context.execute`. No closure variables from the TypeScript side are
+ * visible inside this body.
+ *
+ * Contract: on first invocation, installs `window[ns]` with `{setup, beforeResize,
+ * beforeSnapshot, afterSnapshot, teardown}` handlers; on every invocation, calls
+ * `window[ns][phase]()` if present. The handlers all close over the same set of
+ * private helpers and a `WeakMap`-backed per-element state.
+ */
+/* istanbul ignore next — runs only inside the browser, not in node */
+function pagePayload(arg) {
+    const w = window;
+    const ns = arg.ns;
+    if (!w[ns])
+        install();
+    const state = w[ns];
+    if (state && typeof state[arg.phase] === 'function')
+        state[arg.phase]();
+    function install() {
+        // ----- private state -----
+        const videoUndos = new WeakMap();
+        const captionUndos = new WeakMap();
+        const playerSnapshots = [];
+        const originalProtoPlay = HTMLMediaElement.prototype.play;
+        const originalCreateElement = document.createElement.bind(document);
+        const originalCreateElementNS = document.createElementNS.bind(document);
+        let observer = null;
+        // ----- helpers -----
+        /** Single DOM traversal helper. Visits every element under `root`, recursing into shadow roots. */
+        function walkAll(root, fn) {
+            const els = root.querySelectorAll('*');
+            for (let i = 0; i < els.length; i++) {
+                const el = els[i];
+                fn(el);
+                const sr = el.shadowRoot;
+                if (sr)
+                    walkAll(sr, fn);
+            }
+        }
+        function walkVideos(root, fn) {
+            walkAll(root, el => {
+                if (el.tagName === 'VIDEO')
+                    fn(el);
+            });
+        }
+        function walkCaptions(root, fn) {
+            walkAll(root, el => {
+                const cl = el.classList;
+                if (cl && cl.contains('vjs-text-track-display'))
+                    fn(el);
+            });
+        }
+        /**
+         * Replace an own-property on `obj` with `replacement` and return a closure that
+         * puts the original back. Restores correctly whether the original lived on the
+         * instance or only on the prototype.
+         */
+        function overrideOwn(obj, key, replacement) {
+            const wasOwn = Object.prototype.hasOwnProperty.call(obj, key);
+            const original = wasOwn ? obj[key] : undefined;
+            obj[key] = replacement;
+            return function restore() {
+                if (wasOwn)
+                    obj[key] = original;
+                else
+                    delete obj[key];
+            };
+        }
+        function runUndos(undos) {
+            for (let i = undos.length - 1; i >= 0; i--) {
+                try {
+                    undos[i]();
+                }
+                catch (_) {
+                    // best-effort restore: a failure here must not block the rest
+                }
+            }
+        }
+        // ----- locking primitives -----
+        function lockVideo(video) {
+            if (videoUndos.has(video))
+                return;
+            const undos = [];
+            // 1. Mask the `autoplay` IDL attribute so reads return false and writes are dropped.
+            const hadAutoplay = video.hasAttribute('autoplay');
+            if (hadAutoplay)
+                video.removeAttribute('autoplay');
+            try {
+                Object.defineProperty(video, 'autoplay', {
+                    configurable: true,
+                    get: () => false,
+                    set: () => { },
+                });
+            }
+            catch (_) { }
+            undos.push(() => {
+                try {
+                    delete video.autoplay;
+                }
+                catch (_) { }
+                if (hadAutoplay)
+                    video.setAttribute('autoplay', '');
+            });
+            // 2. setAttribute('autoplay', ...) — BrightCove uses this directly, bypassing the IDL setter.
+            undos.push(overrideOwn(video, 'setAttribute', function (name, value) {
+                if (name === 'autoplay')
+                    return;
+                return Element.prototype.setAttribute.call(this, name, value);
+            }));
+            // 3. Make captureStream() return zero video tracks so dom-snapshot's buildBlobVideos
+            //    skips its play()/record/pause cycle entirely.
+            if (video.captureStream) {
+                undos.push(overrideOwn(video, 'captureStream', function () {
+                    return { getVideoTracks: () => [] };
+                }));
+            }
+            // 4. Disable text tracks (caption rendering source).
+            const tracks = video.textTracks;
+            const savedModes = [];
+            for (let i = 0; i < tracks.length; i++) {
+                savedModes.push(tracks[i].mode);
+                tracks[i].mode = 'disabled';
+            }
+            undos.push(() => {
+                const t = video.textTracks;
+                for (let i = 0; i < t.length && i < savedModes.length; i++)
+                    t[i].mode = savedModes[i];
+            });
+            videoUndos.set(video, undos);
+        }
+        function unlockVideo(video) {
+            const undos = videoUndos.get(video);
+            if (!undos)
+                return;
+            videoUndos.delete(video);
+            runUndos(undos);
+        }
+        /**
+         * Lock a .vjs-text-track-display caption container. Instance-level overrides because
+         * BrightCove's event handlers re-inject cue elements in microtasks between our
+         * phase call returning and dom-snapshot serializing the DOM — synchronous, persistent
+         * overrides intercept every insertion path regardless of timing.
+         */
+        function lockCaption(c) {
+            if (captionUndos.has(c))
+                return;
+            const undos = [];
+            while (c.firstChild)
+                c.removeChild(c.firstChild);
+            undos.push(overrideOwn(c, 'appendChild', (n) => n));
+            undos.push(overrideOwn(c, 'insertBefore', (n) => n));
+            undos.push(overrideOwn(c, 'insertAdjacentHTML', () => { }));
+            undos.push(overrideOwn(c, 'insertAdjacentElement', (_pos, n) => n));
+            try {
+                Object.defineProperty(c, 'innerHTML', {
+                    configurable: true,
+                    get: () => '',
+                    set: () => { },
+                });
+                undos.push(() => {
+                    try {
+                        delete c.innerHTML;
+                    }
+                    catch (_) { }
+                });
+            }
+            catch (_) { }
+            captionUndos.set(c, undos);
+        }
+        function unlockCaption(c) {
+            const undos = captionUndos.get(c);
+            if (!undos)
+                return;
+            captionUndos.delete(c);
+            runUndos(undos);
+        }
+        // ----- player container snapshot / restore -----
+        function snapshotPlayers() {
+            walkVideos(document, video => {
+                const playerEl = video.closest('video-js, [data-vjs-player], .video-js');
+                playerSnapshots.push({
+                    video,
+                    paused: video.paused,
+                    currentTime: video.currentTime,
+                    playerEl,
+                    playerClasses: playerEl ? Array.from(playerEl.classList) : [],
+                });
+            });
+        }
+        function restorePlayers() {
+            for (let i = 0; i < playerSnapshots.length; i++) {
+                const s = playerSnapshots[i];
+                if (s.paused && !s.video.paused) {
+                    s.video.pause();
+                    try {
+                        s.video.currentTime = s.currentTime;
+                    }
+                    catch (_) { } // MSE may reject seeks
+                }
+                if (s.playerEl) {
+                    const current = Array.from(s.playerEl.classList);
+                    for (let j = 0; j < current.length; j++) {
+                        if (s.playerClasses.indexOf(current[j]) === -1)
+                            s.playerEl.classList.remove(current[j]);
+                    }
+                    for (let j = 0; j < s.playerClasses.length; j++)
+                        s.playerEl.classList.add(s.playerClasses[j]);
+                }
+            }
+        }
+        // ----- global patches (live for the entire loop) -----
+        function patchGlobals() {
+            // video.js calls HTMLMediaElement.prototype.play.call(el) directly — prototype patch is mandatory.
+            // Stays alive through teardown's restorePlayers() so BrightCove's pause-event handler
+            // cannot call the (now-live) native play() and restart playback.
+            ;
+            HTMLMediaElement.prototype.play = function () {
+                return Promise.resolve();
+            };
+            document.createElement = function (tag) {
+                const el = originalCreateElement(tag);
+                if (typeof tag === 'string' && tag.toLowerCase() === 'video') {
+                    lockVideo(el);
+                }
+                return el;
+            };
+            document.createElementNS = function (nsArg, tag) {
+                const el = originalCreateElementNS(nsArg, tag);
+                if (typeof tag === 'string' && tag.toLowerCase() === 'video') {
+                    lockVideo(el);
+                }
+                return el;
+            };
+        }
+        function unpatchGlobals() {
+            ;
+            HTMLMediaElement.prototype.play = originalProtoPlay;
+            document.createElement = originalCreateElement;
+            document.createElementNS = originalCreateElementNS;
+        }
+        // ----- mutation observer (belt-and-suspenders for late-arriving nodes) -----
+        function startObserver() {
+            observer = new MutationObserver(mutations => {
+                for (let i = 0; i < mutations.length; i++) {
+                    const added = mutations[i].addedNodes;
+                    for (let j = 0; j < added.length; j++) {
+                        const node = added[j];
+                        if (!(node instanceof Element))
+                            continue;
+                        if (node.tagName === 'VIDEO')
+                            lockVideo(node);
+                        else if (node.classList && node.classList.contains('vjs-text-track-display'))
+                            lockCaption(node);
+                        walkVideos(node, lockVideo);
+                        walkCaptions(node, lockCaption);
+                    }
+                }
+            });
+            observer.observe(document, { childList: true, subtree: true });
+        }
+        function stopObserver() {
+            if (observer) {
+                observer.disconnect();
+                observer = null;
+            }
+        }
+        // ----- bootstrap -----
+        // Player state is NOT snapshotted here. It is captured fresh in `beforeSnapshot`
+        // so that responsive classes (vjs-layout-small, vjs-fluid, orientation classes)
+        // applied during setViewportSize are preserved across afterSnapshot's restore.
+        // This also automatically covers videos BrightCove injects mid-loop, since the
+        // walk re-runs each iteration.
+        patchGlobals();
+        walkCaptions(document, lockCaption);
+        startObserver();
+        // ----- phase handlers (called from TS via runPhase) -----
+        w[ns] = {
+            // `setup` is already complete by the time we get here; the no-op handler keeps the dispatch shape uniform.
+            setup() { },
+            beforeResize() {
+                walkVideos(document, lockVideo);
+                walkCaptions(document, lockCaption);
+            },
+            beforeSnapshot() {
+                // Safety net first — pause videos and disable tracks before snapshotting state,
+                // so playback classes (vjs-playing) settle to a consistent paused-state.
+                walkVideos(document, video => {
+                    if (!video.paused)
+                        video.pause();
+                    const t = video.textTracks;
+                    for (let i = 0; i < t.length; i++)
+                        t[i].mode = 'disabled';
+                });
+                // Capture fresh per-player state — runs after resize so responsive classes
+                // reflect the current breakpoint, and so videos BrightCove injected during
+                // the resize are included.
+                playerSnapshots.length = 0;
+                snapshotPlayers();
+                // MutationObserver is async; lock new caption containers synchronously before
+                // dom-snapshot's next-macrotask serialization runs.
+                walkCaptions(document, lockCaption);
+            },
+            afterSnapshot() {
+                walkVideos(document, unlockVideo);
+                restorePlayers();
+                // Clear after consume — the captured state is breakpoint-specific and must not
+                // leak into the next iteration or teardown, where the viewport differs.
+                playerSnapshots.length = 0;
+            },
+            teardown() {
+                // Restore players BEFORE unpatching globals: BrightCove's pause-event handler can call
+                // play() during pause(), and we need that call to still hit the no-op prototype patch.
+                restorePlayers();
+                stopObserver();
+                unpatchGlobals();
+                walkVideos(document, unlockVideo);
+                walkCaptions(document, unlockCaption);
+                delete w[ns];
+            },
+        };
+    }
+}
+exports.pagePayload = pagePayload;

package/dist/ufg/utils/take-dom-snapshots.js

@@ -34,6 +34,7 @@ const take_dom_snapshot_1 = require("./take-dom-snapshot");
 const generate_safe_selectors_1 = require("./generate-safe-selectors");
 const wait_for_lazy_load_1 = require("../../automation/utils/wait-for-lazy-load");
 const calculate_required_sizes_1 = require("../../automation/utils/calculate-required-sizes");
+const media_playback_guard_1 = require("./media-playback-guard");
 const chalk_1 = __importDefault(require("chalk"));
 const utils = __importStar(require("@applitools/utils"));
 const lang = __importStar(require("../../lang"));
@@ -85,9 +86,12 @@ async function takeDomSnapshots({ driver, settings, hooks, provides, logger, })
         context: currentContext,
         elementReferences: settings.elementReferences,
     });
+    const mediaGuard = (0, media_playback_guard_1.makeMediaPlaybackGuard)({ context: currentContext, logger });
+    await mediaGuard.setup();
     const snapshots = Array(settings.environments.length);
     for (const [index, { viewportSize, browsers }] of entries.entries()) {
         logger.log(`Taking dom snapshot for viewport size ${viewportSize}`);
+        await mediaGuard.beforeResize();
         if (viewportSize) {
             try {
                 await driver.setViewportSize(viewportSize);
@@ -121,10 +125,13 @@ async function takeDomSnapshots({ driver, settings, hooks, provides, logger, })
             await (0, wait_for_lazy_load_1.waitForLazyLoad)({ context: currentContext, settings: settings.lazyLoad, logger });
         }
         await beforeEachSnapshot();
+        await mediaGuard.beforeSnapshot();
         const snapshot = await (0, take_dom_snapshot_1.takeDomSnapshot)({ context: currentContext, settings, logger });
         browsers.forEach(({ index }) => (snapshots[index] = snapshot));
+        await mediaGuard.afterSnapshot();
     }
     await driver.setViewportSize(initialViewportSize);
+    await mediaGuard.teardown();
     if (settings.layoutBreakpoints.reload) {
         await driver.reloadPage();
         await beforeEachSnapshot();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "4.63.0",
+  "version": "4.64.0",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -61,19 +61,19 @@
     "setup:standalone": "sh -c 'yarn chromedriver --port=4444 --verbose &'"
   },
   "dependencies": {
-    "@applitools/core-base": "1.34.0",
-    "@applitools/dom-capture": "11.8.0",
-    "@applitools/dom-snapshot": "4.17.1",
-    "@applitools/driver": "1.26.1",
-    "@applitools/ec-client": "1.12.29",
-    "@applitools/logger": "2.2.11",
-    "@applitools/nml-client": "1.11.27",
-    "@applitools/req": "1.10.1",
-    "@applitools/screenshoter": "3.12.20",
-    "@applitools/snippets": "2.9.1",
-    "@applitools/socket": "1.3.12",
-    "@applitools/ufg-client": "1.22.1",
-    "@applitools/utils": "1.14.4",
+    "@applitools/core-base": "1.35.0",
+    "@applitools/dom-capture": "11.8.1",
+    "@applitools/dom-snapshot": "4.17.2",
+    "@applitools/driver": "1.26.2",
+    "@applitools/ec-client": "1.12.31",
+    "@applitools/logger": "2.2.12",
+    "@applitools/nml-client": "1.11.29",
+    "@applitools/req": "1.10.2",
+    "@applitools/screenshoter": "3.12.21",
+    "@applitools/snippets": "2.9.2",
+    "@applitools/socket": "1.3.13",
+    "@applitools/ufg-client": "1.22.2",
+    "@applitools/utils": "1.14.5",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
     "node-fetch": "2.6.7",
@@ -82,12 +82,12 @@
   },
   "devDependencies": {
     "@applitools/bongo": "^5.10.0",
-    "@applitools/spec-driver-playwright": "^1.9.1",
-    "@applitools/spec-driver-puppeteer": "^1.8.1",
-    "@applitools/spec-driver-selenium": "^1.8.1",
-    "@applitools/test-server": "^1.4.3",
+    "@applitools/spec-driver-playwright": "^1.9.2",
+    "@applitools/spec-driver-puppeteer": "^1.8.2",
+    "@applitools/spec-driver-selenium": "^1.8.2",
+    "@applitools/test-server": "^1.4.4",
     "@applitools/test-utils": "^1.5.17",
-    "@applitools/tunnel-client": "^1.11.13",
+    "@applitools/tunnel-client": "^1.11.14",
     "@swc-node/register": "^1.6.8",
     "@types/mocha": "^10.0.7",
     "@types/node": "^12.20.55",

package/types/automation/get-nml-client.d.ts

@@ -12,6 +12,6 @@ export declare function makeGetNMLClient({ client, logger: mainLogger }: Options
         settings: Omit<NMLClientSettings, 'brokerUrl'>;
         logger: Logger;
     }) => Promise<NMLClient>;
-    clearNMLClientCache: (driver: Driver<SpecType>) => Promise<void>;
+    disableNMLClientCache: (driver: Driver<SpecType>) => Promise<void>;
 };
 export {};

package/types/automation/types.d.ts

@@ -67,7 +67,7 @@ export interface Core<TSpec extends SpecType> extends Omit<BaseCore.Core, 'openE
         driver: Driver<TSpec>;
         logger: Logger;
     }): Promise<NMLClient>;
-    clearNMLClientCache(driver: Driver<TSpec>): Promise<void>;
+    disableNMLClientCache(driver: Driver<TSpec>): Promise<void>;
     openEyes(options: {
         target?: DriverTarget<TSpec>;
         settings: BaseCore.OpenSettings;

package/types/ufg/to-old-infra-environment.d.ts

@@ -0,0 +1,7 @@
+import type { Environment as UFGEnvironment } from '@applitools/ufg-client';
+/**
+ * Returns the same UFG environment retargeted at the previous browser/OS version,
+ * or `null` if the input is not at a latest-alias environment (already one-version-back,
+ * pinned to a specific version, or an unsupported browser).
+ */
+export declare function toOldInfraEnvironment(env: UFGEnvironment): UFGEnvironment | null;

package/types/ufg/utils/media-playback-guard.d.ts

@@ -0,0 +1,67 @@
+import { type SpecType, type Context } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+/**
+ * Prevents media playback side-effects during the layoutBreakpoints snapshot loop.
+ *
+ * dom-snapshot calls video.play() per breakpoint to capture a video frame. For
+ * BrightCove / video.js players this triggers CSS class changes (has-started, is-playing)
+ * and subtitle text injection that outlast the corresponding pause() call. With multiple
+ * breakpoints the mutations accumulate and corrupt visual snapshots.
+ *
+ * Lifecycle:
+ *   const guard = makeMediaPlaybackGuard({context, logger})
+ *   await guard.setup()                          // once, before the loop
+ *   for (const entry of entries) {
+ *     await guard.beforeResize()                 // before setViewportSize
+ *     // setViewportSize / reload / lazyLoad
+ *     await guard.beforeSnapshot()               // after resize, before takeDomSnapshot
+ *     // takeDomSnapshot
+ *     await guard.afterSnapshot()                // after takeDomSnapshot
+ *   }
+ *   // setViewportSize (restore)
+ *   await guard.teardown()                       // once, after final viewport restore
+ *
+ * Implementation notes:
+ *
+ * The TypeScript layer is just orchestration — `setup` / `beforeResize` / etc. each
+ * dispatch a phase name to a single self-contained page-side payload (`pagePayload`
+ * below) via `context.execute`. The first call installs a library at `window[ns]`
+ * with one handler per lifecycle method; subsequent calls just look up and run
+ * `window[ns][phase]()`. Teardown deletes `window[ns]` so a fresh guard starts clean.
+ *
+ *   - `ns` is randomised per guard instance so concurrent guards on the same page
+ *     (e.g. nested checks) do not collide.
+ *   - Per-element state lives in a `WeakMap`, not on the elements themselves — no
+ *     marker properties leak onto the page's DOM.
+ *   - A single `walkAll(root, fn)` helper handles every Document/ShadowRoot traversal.
+ *   - A `MutationObserver` covers the gap between phase calls (e.g. videos that
+ *     BrightCove creates during setViewportSize). The synchronous walks in
+ *     `beforeSnapshot` remain because the observer fires on a microtask and would
+ *     otherwise lose the race against dom-snapshot's serialization.
+ */
+export declare function makeMediaPlaybackGuard<TSpec extends SpecType>({ context, logger, }: {
+    context: Context<TSpec>;
+    logger: Logger;
+}): {
+    setup: () => Promise<void>;
+    beforeResize: () => Promise<void>;
+    beforeSnapshot: () => Promise<void>;
+    afterSnapshot: () => Promise<void>;
+    teardown: () => Promise<void>;
+};
+type Phase = 'setup' | 'beforeResize' | 'beforeSnapshot' | 'afterSnapshot' | 'teardown';
+/**
+ * The entire page-side library — a single self-contained function shipped to the
+ * browser by `context.execute`. No closure variables from the TypeScript side are
+ * visible inside this body.
+ *
+ * Contract: on first invocation, installs `window[ns]` with `{setup, beforeResize,
+ * beforeSnapshot, afterSnapshot, teardown}` handlers; on every invocation, calls
+ * `window[ns][phase]()` if present. The handlers all close over the same set of
+ * private helpers and a `WeakMap`-backed per-element state.
+ */
+export declare function pagePayload(arg: {
+    ns: string;
+    phase: Phase;
+}): void;
+export {};