@applitools/core 4.74.2 → 4.75.0

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # Changelog
 
+## [4.75.0](https://github.com/Applitools-Dev/sdk/compare/js/core@4.74.2...js/core@4.75.0) (2026-11-05)
+
+
+### Features
+
+* run the Eyes session lifecycle on the task graph | AD-16964 ([#4361](https://github.com/Applitools-Dev/sdk/issues/4361)) ([51eb00f](https://github.com/Applitools-Dev/sdk/commit/51eb00f60f5e95a91689f170192b4d7d580437af))
+
+
+### Code Refactoring
+
+* split deps from after, typed labels, filler awaits | AD-16964 ([#4362](https://github.com/Applitools-Dev/sdk/issues/4362)) ([6aaf46b](https://github.com/Applitools-Dev/sdk/commit/6aaf46be75059911917c8c31e8e008126cea2c5a))
+
+
+### Dependencies
+
+* @applitools/task-manager bumped to 1.0.0
+  #### Features
+
+  * dependency-aware task graph package | AD-16964 ([#4360](https://github.com/Applitools-Dev/sdk/issues/4360)) ([6690133](https://github.com/Applitools-Dev/sdk/commit/66901337363cfec42b8cd7caa0f41e8ea3f71a6c))
+  * run the Eyes session lifecycle on the task graph | AD-16964 ([#4361](https://github.com/Applitools-Dev/sdk/issues/4361)) ([51eb00f](https://github.com/Applitools-Dev/sdk/commit/51eb00f60f5e95a91689f170192b4d7d580437af))
+
+
+  #### Code Refactoring
+
+  * split deps from after, typed labels, filler awaits | AD-16964 ([#4362](https://github.com/Applitools-Dev/sdk/issues/4362)) ([6aaf46b](https://github.com/Applitools-Dev/sdk/commit/6aaf46be75059911917c8c31e8e008126cea2c5a))
+
+
+  #### Miscellaneous Chores
+
+  * release as 1.0.0 | AD-16964 ([d1b823c](https://github.com/Applitools-Dev/sdk/commit/d1b823c2974ca64e50ff0c53890ed0594a53dc74))
+* @applitools/ufg-client bumped to 1.26.0
+  #### Features
+
+  * run the Eyes session lifecycle on the task graph | AD-16964 ([#4361](https://github.com/Applitools-Dev/sdk/issues/4361)) ([51eb00f](https://github.com/Applitools-Dev/sdk/commit/51eb00f60f5e95a91689f170192b4d7d580437af))
+
+
+  #### Code Refactoring
+
+  * split deps from after, typed labels, filler awaits | AD-16964 ([#4362](https://github.com/Applitools-Dev/sdk/issues/4362)) ([6aaf46b](https://github.com/Applitools-Dev/sdk/commit/6aaf46be75059911917c8c31e8e008126cea2c5a))
+* @applitools/nml-client bumped to 1.12.13
+
+* @applitools/core-base bumped to 1.42.0
+  #### Features
+
+  * run the Eyes session lifecycle on the task graph | AD-16964 ([#4361](https://github.com/Applitools-Dev/sdk/issues/4361)) ([51eb00f](https://github.com/Applitools-Dev/sdk/commit/51eb00f60f5e95a91689f170192b4d7d580437af))
+
+
+  #### Code Refactoring
+
+  * split deps from after, typed labels, filler awaits | AD-16964 ([#4362](https://github.com/Applitools-Dev/sdk/issues/4362)) ([6aaf46b](https://github.com/Applitools-Dev/sdk/commit/6aaf46be75059911917c8c31e8e008126cea2c5a))
+* @applitools/ec-client bumped to 1.12.57
+
+
 ## [4.74.2](https://github.com/Applitools-Dev/sdk/compare/js/core@4.74.1...js/core@4.74.2) (2026-11-04)
 
 

package/README.md

@@ -63,8 +63,8 @@ check()
 2. **Scroll root / lazy load** — the driver scrolls and waits for deferred content
 3. **Screenshot** — a full-page or viewport PNG is captured locally
 4. **DOM capture** (optional) — if `sendDom=true`, the serialized DOM is captured for Root Cause Analysis (RCA)
-5. **Session open** (lazy) — `getBaseEyes()` opens the Applitools test session on first use
-6. **Upload + compare** — `baseEyes.check()` uploads the image+DOM and triggers comparison
+5. **Session open** (lazy) — the environment's `open` task runs once a check needs it
+6. **Upload + compare** — the `upload` task uploads the image+DOM (`baseEyes.uploadTarget()`), then the `match` task triggers comparison (`baseEyes.match()`)
 
 ### matchTimeout behavior
 
@@ -98,14 +98,14 @@ check()
   │     ├── createRenderTargetFromSnapshot()
   │     │     └── ufgClient.uploadResources()  ← CSS, fonts, images → UFG CDN
   │     │
-  │     ├── getBaseEyes()   ← open test session (lazy, per environment)
+  │     ├── open task   ← open test session (lazy, per environment)
   │     │
   │     ├── ufgClient.render()
   │     │     └── UFG renders DOM in target browser/device → returns rendered image
   │     │
-  │     └── baseEyes.check()  ← compare rendered image against baseline
+  │     └── baseEyes.match()  ← compare rendered image against baseline
   │
-  └── all environment promises queued in eyes.storage
+  └── each environment's tasks run on core's task graph (src/tasks/)
 ```
 
 ### Key files
@@ -123,8 +123,8 @@ check()
 2. **DOM snapshot** — the page's full DOM (HTML, CSS, iframes) is serialized and resources are collected
 3. **Resource upload** — CSS, fonts, images are uploaded to the UFG CDN (cached by URL to avoid re-uploads)
 4. **Render request** — sent to the UFG rendering farm per target environment (browser + viewport or device)
-5. **Session open** (lazy, per environment) — `getBaseEyes()` opens one Applitools session per environment
-6. **Compare** — `baseEyes.check()` receives the rendered image reference (`renderId`) and triggers comparison
+5. **Session open** (lazy, per environment) — each environment's `open` task opens its Applitools session
+6. **Compare** — the `match` task sends the rendered image reference (`renderId`) to `baseEyes.match()`, which triggers comparison
 
 ### Environment targeting
 
@@ -171,7 +171,7 @@ Two distinct environment shapes flow through classic check. Confusing them is th
 | **Requested environment** (also called *unique environment*) | `RenderEnvironment` | `{iosDeviceInfo: {deviceName: 'iPhone 12'}}` or `{name: 'chrome', width: 1280, height: 800}` | Comes from `settings.environments` (user input). After `uniquifyEnvironments()`, duplicates get a synthetic `environmentId` to map to separate sessions. |
 | **Actual / exact environment** | `ExactEnvironment` | `{environmentId, deviceName, os, viewportSize, requested: <RenderEnvironment>}` | Returned by `takeWebScreenshot` / `takeNMLScreenshot` after the device is resolved. The flat shape that `core-base` and the Applitools server understand. Always has `requested` pointing back to the original `RenderEnvironment`. |
 
-**Key invariant:** `toEnvironmentKey(exactEnvironment)` === `toEnvironmentKey(requestedEnvironment)` because `toEnvironmentKey` uses `env.requested ?? env`. This is how the `makeGetBaseEyes` cache correctly matches an early session-open (keyed on the requested environment) to the later check (keyed on the exact environment).
+**Key invariant:** `toEnvironmentKey(exactEnvironment)` === `toEnvironmentKey(requestedEnvironment)` because `toEnvironmentKey` uses `env.requested ?? env`. This is how a check keyed on the exact environment finds the open declared for the requested one.
 
 **Known bug:** In the `matchTimeout` path, `base.openEyes` is called with the *requested* environment (`{iosDeviceInfo: ...}`) instead of the *exact* environment (`{deviceName, os, viewportSize, ...}`). `core-base/server/requests.ts` reads the flat fields (`os`, `deviceName`, `viewportSize`) which are `undefined` on the requested form, so the session opens on the server with empty environment info. This only affects NML (iOS/Android native) environments since web environments are not transformed and `exactEnvironment === requestedEnvironment`.
 
@@ -179,22 +179,17 @@ Two distinct environment shapes flow through classic check. Confusing them is th
 
 ## Session Lifecycle (Both Strategies)
 
-Sessions are opened **lazily** — the Applitools test session is not created during `openEyes()`, but on the first `getBaseEyes()` call within a check. This avoids charging concurrency for tests that open but never check.
+Sessions are opened **lazily** — `openEyes()` declares a lazy `open` task per environment (`src/tasks/`); the first check's steps activate it, and a close or abort dismisses one nothing needed. This avoids charging concurrency for tests that open but never check.
 
 ```
-openEyes()         → creates in-memory Eyes object, no server call
-check()            → getBaseEyes() → POST /api/sessions (first time only)
-check()            → getBaseEyes() → returns cached session (subsequent calls)
-close() / abort()  → closes all open sessions, awaits all queued jobs
+openEyes()         → declares lazy opens, no server call
+check()            → activates the env's open → POST /api/sessions (first time only)
+close()            → one close task per environment, after its last step
+abort()            → one abort task per environment, as soon as it is open (doesn't wait for steps)
 ```
 
 ---
 
-## Storage Model
+## Task Graph
 
-Both strategies push check promises into `eyes.storage`, a `Map<environmentKey, {eyes, jobs[]}>`:
-
-- `eyes` — a controlled promise resolving to the base eyes session
-- `jobs` — array of check promises for that environment
-
-`close()` waits for all jobs across all environments before collecting results.
+Both strategies add their steps to core's task graph (`src/tasks/`), each task labeled `{session, env}`; close, abort and getResults query it for each environment's tasks.

package/dist/automation/abort.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeAbort = void 0;
 const uniquify_environments_1 = require("./utils/uniquify-environments");
-function makeAbort({ eyes, driver, controller, environments: defaultEnvironments, logger: mainLogger, }) {
+const tasks_1 = require("../tasks");
+function makeAbort({ eyes, driver, controller, logger: mainLogger }) {
     return async function abort({ settings, logger = mainLogger, } = {}) {
-        var _a;
         logger = logger.extend(mainLogger);
         logger.log('Command "abort" is called with settings', settings);
         if (!eyes.running) {
@@ -15,6 +15,7 @@ function makeAbort({ eyes, driver, controller, environments: defaultEnvironments
             ;
             eyes.running = false;
         }
+        // Signal in-flight checks; queued and later steps self-abort (they read `signal`/`baseEyes.running`).
         controller.abort();
         settings !== null && settings !== void 0 ? settings : (settings = {});
         if (!settings.testMetadata && driver) {
@@ -25,23 +26,12 @@ function makeAbort({ eyes, driver, controller, environments: defaultEnvironments
                 logger.warn('Command "abort" received an error during extracting driver metadata', error);
             }
         }
-        (_a = settings.environments) !== null && _a !== void 0 ? _a : (settings.environments = defaultEnvironments);
-        if (eyes.storage.size === 0 && settings.environments && settings.environments.length > 0) {
-            const uniqueEnvironments = (0, uniquify_environments_1.uniquifyEnvironments)(settings.environments);
-            logger.log('Command "abort" starting filler tests for environments', uniqueEnvironments);
-            await Promise.all(uniqueEnvironments.map(environment => eyes.getBaseEyes({ settings: { environment }, logger })));
+        const fillers = (0, tasks_1.declareFillers)(eyes, settings.environments && (0, uniquify_environments_1.uniquifyEnvironments)(settings.environments), logger);
+        if (fillers.length > 0) {
+            logger.log('Command "abort" starting filler tests for environments', fillers.map(open => open.labels.env));
+            await Promise.all(fillers.map(open => open.promise));
         }
-        eyes.storage.forEach(async (item) => {
-            var _a, _b;
-            try {
-                const eyes = await item.eyes;
-                await eyes.abort({ settings, logger });
-            }
-            catch (error) {
-                logger.warn('Command "abort" received an error during waiting for eyes instances in background', error);
-                await ((_b = (_a = error === null || error === void 0 ? void 0 : error.info) === null || _a === void 0 ? void 0 : _a.eyes) === null || _b === void 0 ? void 0 : _b.abort({ settings, logger }));
-            }
-        });
+        (0, tasks_1.abortSession)(eyes.session, { settings, logger });
     };
 }
 exports.makeAbort = makeAbort;

package/dist/automation/close.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeClose = void 0;
 const uniquify_environments_1 = require("./utils/uniquify-environments");
-function makeClose({ eyes, driver, environments: defaultEnvironments, logger: mainLogger, }) {
+const tasks_1 = require("../tasks");
+function makeClose({ eyes, driver, logger: mainLogger }) {
     return async function close({ settings, logger = mainLogger, } = {}) {
-        var _a;
         logger = logger.extend(mainLogger);
         logger.log('Command "close" is called with settings', settings);
         if (!eyes.running) {
@@ -16,6 +16,7 @@ function makeClose({ eyes, driver, environments: defaultEnvironments, logger: ma
             eyes.running = false;
         }
         settings !== null && settings !== void 0 ? settings : (settings = {});
+        // testMetadata must be set before the closes are added — a fused matchandend reports self-heal from it.
         if (!settings.testMetadata && driver) {
             try {
                 settings.testMetadata = await driver.getSessionMetadata();
@@ -24,32 +25,12 @@ function makeClose({ eyes, driver, environments: defaultEnvironments, logger: ma
                 logger.warn('Command "close" received an error during extracting driver metadata', error);
             }
         }
-        (_a = settings.environments) !== null && _a !== void 0 ? _a : (settings.environments = defaultEnvironments);
-        if (eyes.storage.size === 0 && settings.environments && settings.environments.length > 0) {
-            const uniqueEnvironments = (0, uniquify_environments_1.uniquifyEnvironments)(settings.environments);
-            logger.log('Command "close" starting filler tests for environments', settings.environments);
-            await Promise.all(uniqueEnvironments.map(environment => eyes.getBaseEyes({ settings: { environment }, logger })));
+        const fillers = (0, tasks_1.declareFillers)(eyes, settings.environments && (0, uniquify_environments_1.uniquifyEnvironments)(settings.environments), logger);
+        if (fillers.length > 0) {
+            logger.log('Command "close" starting filler tests for environments', fillers.map(open => open.labels.env));
+            await Promise.all(fillers.map(open => open.promise));
         }
-        eyes.storage.forEach(item => {
-            const closePromise = (async () => {
-                var _a, _b;
-                try {
-                    const [eyes] = await Promise.all([item.eyes, ...item.jobs]);
-                    try {
-                        await eyes.close({ settings, logger });
-                    }
-                    catch (error) {
-                        logger.warn('Command "close" received an error during performing, trying to perform abort instead', error);
-                        await eyes.abort({ settings, logger });
-                    }
-                }
-                catch (error) {
-                    logger.warn('Command "close" received an error during waiting for eyes instances in background', error);
-                    await ((_b = (_a = error.info) === null || _a === void 0 ? void 0 : _a.eyes) === null || _b === void 0 ? void 0 : _b.abort({ settings, logger }));
-                }
-            })();
-            item.jobs.push(closePromise);
-        });
+        (0, tasks_1.closeSession)(eyes.session, { settings, logger });
     };
 }
 exports.makeClose = makeClose;

package/dist/automation/get-results.js

@@ -1,21 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetResults = void 0;
+const tasks_1 = require("../tasks");
 function makeGetResults({ eyes, logger: mainLogger }) {
     return async function getResults({ settings, logger = mainLogger, } = {}) {
         logger = logger.extend(mainLogger);
         logger.log('Command "getResults" is called with settings', settings);
-        return Promise.all(Array.from(eyes.storage.values(), async (item) => {
-            try {
-                const [eyes] = await Promise.all([item.eyes, ...item.jobs]);
-                const [result] = await eyes.getResults({ settings, logger });
-                return { ...result, environment: eyes.test.environment };
-            }
-            catch (error) {
-                logger.fatal('Command "getResults" received an error', error, 'during performing with settings', settings);
-                throw error;
-            }
-        }));
+        const results = await Promise.all((0, tasks_1.activeEnvironmentKeys)(eyes.session).map(key => (0, tasks_1.getResults)(eyes.session, key, { settings, logger })));
+        return results;
     };
 }
 exports.makeGetResults = makeGetResults;

package/dist/automation/utils/make-environment-loggers.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEnvironmentLoggers = void 0;
+const to_environment_key_1 = require("./to-environment-key");
+const utils = __importStar(require("@applitools/utils"));
+// One `environment-*` tag per environment, extended onto each caller's logger so per-call tags are kept.
+function makeEnvironmentLoggers() {
+    const tags = new Map();
+    return function getEnvironmentLogger(environment, logger) {
+        const key = (0, to_environment_key_1.toEnvironmentKey)(environment);
+        if (!tags.has(key))
+            tags.set(key, `environment-${utils.general.shortid()}`);
+        return logger.extend({ tags: [tags.get(key)] });
+    };
+}
+exports.makeEnvironmentLoggers = makeEnvironmentLoggers;

package/dist/automation/utils/to-environment-key.js

@@ -26,6 +26,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.toEnvironmentKey = void 0;
 const utils = __importStar(require("@applitools/utils"));
 function toEnvironmentKey(environment) {
-    return JSON.stringify(utils.types.has(environment, 'requested') ? environment.requested : environment);
+    return JSON.stringify(utils.types.has(environment, 'requested') ? environment.requested : environment, sortKeys);
 }
 exports.toEnvironmentKey = toEnvironmentKey;
+function sortKeys(_key, value) {
+    return utils.types.isPlainObject(value)
+        ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => (a < b ? -1 : 1)))
+        : value;
+}

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

@@ -35,9 +35,12 @@ const wait_for_lazy_load_1 = require("../automation/utils/wait-for-lazy-load");
 const uniquify_environments_1 = require("../automation/utils/uniquify-environments");
 const to_environment_key_1 = require("../automation/utils/to-environment-key");
 const abort_error_1 = require("../errors/abort-error");
+const tasks_1 = require("../tasks");
+const steps_1 = require("../tasks/classic/steps");
 const chalk_1 = __importDefault(require("chalk"));
 const utils = __importStar(require("@applitools/utils"));
 const lang = __importStar(require("../lang"));
+const ABORTED = 'Command "checkAndClose" was aborted before checking';
 function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultEnvironments = [], spec, signal, logger: mainLogger, }) {
     return async function checkAndClose({ target = defaultTarget, settings = {}, logger = mainLogger, } = {}) {
         var _a, _b, _c;
@@ -56,6 +59,8 @@ function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultE
         let driver;
         if ((0, driver_1.isDriver)(target, spec)) {
             driver = await (0, driver_1.makeDriver)({ spec, driver: target, reset: target === defaultTarget, logger });
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                return (0, tasks_1.addAbortedCheck)(eyes, uniqueEnvironments, ABORTED, logger);
             await driver.currentContext.setScrollingElement((_b = settings.scrollRootElement) !== null && _b !== void 0 ? _b : null);
             const driverEnvironment = await driver.getEnvironment();
             uniqueEnvironments.forEach(environment => {
@@ -162,76 +167,28 @@ function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultE
             baseTargets.push(target);
             baseSettings.push(settings);
         }
-        const promises = exactEnvironments.map(async (environment, index) => {
-            var _a, _b, _c, _d;
-            const environmentLogger = logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
-            try {
-                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                    environmentLogger.warn('Command "checkAndClose" was aborted before checking');
-                    throw new abort_error_1.AbortError('Command "checkAndClose" was aborted before checking');
-                }
-                const baseEyes = await eyes.getBaseEyes({ settings: { environment, driver }, logger: environmentLogger });
-                try {
-                    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                        environmentLogger.warn('Command "checkAndClose" was aborted before checking');
-                        throw new abort_error_1.AbortError('Command "checkAndClose" was aborted before checking');
-                    }
-                    else if (!baseEyes.running) {
-                        environmentLogger.warn(`Check on environment with id "${(_a = baseEyes.test.environment) === null || _a === void 0 ? void 0 : _a.environmentId}" was aborted during one of the previous steps`);
-                        throw new abort_error_1.AbortError(`Check on environment with id "${(_b = baseEyes.test.environment) === null || _b === void 0 ? void 0 : _b.environmentId}" was aborted during one of the previous steps`);
-                    }
-                    if (settings.assumesMutability) {
-                        void eyes.core.logEvent({
-                            settings: {
-                                level: 'Notice',
-                                event: {
-                                    type: 'eyes.check',
-                                    message: 'Assuming mutability for check Target',
-                                    test: {
-                                        checkName: settings.name,
-                                        batchId: baseEyes.test.batchId,
-                                        sessionId: baseEyes.test.sessionId,
-                                        testName: baseEyes.test.testName,
-                                        testId: baseEyes.test.testId,
-                                        userTestId: baseEyes.test.userTestId,
-                                        appId: baseEyes.test.appId,
-                                        baselineId: baseEyes.test.baselineId,
-                                        environmentId: (_c = baseEyes.test.environment) === null || _c === void 0 ? void 0 : _c.environmentId,
-                                    },
-                                    isNew: baseEyes.test.isNew,
-                                    resultsUrl: baseEyes.test.resultsUrl,
-                                },
-                                ...eyes.test.eyesServer,
-                            },
-                            logger: environmentLogger,
-                        });
-                    }
-                    await baseEyes.checkAndClose({
-                        target: baseTargets[index],
-                        settings: baseSettings[index],
-                        logger: environmentLogger,
-                    });
-                }
-                catch (error) {
-                    environmentLogger.error(`Check on environment with id "${(_d = baseEyes.test.environment) === null || _d === void 0 ? void 0 : _d.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 } });
-                }
-            }
-            catch (error) {
-                environmentLogger.error(`Environment with id ${environment.environmentId} failed before checking started due to an error`, error);
-                error.info = { ...error.info, userTestId: eyes.test.userTestId, environment: environment };
-                throw error;
-            }
-        });
+        const mutability = settings.assumesMutability ? { eyes, checkName: settings.name } : undefined;
         exactEnvironments.forEach((environment, index) => {
-            const key = (0, to_environment_key_1.toEnvironmentKey)(environment);
-            let item = eyes.storage.get(key);
-            if (!item) {
-                item = { eyes: utils.promises.makeControlledPromise(), jobs: [] };
-                eyes.storage.set(key, item);
-            }
-            item.jobs.push(promises[index]);
+            const environmentLogger = eyes.getEnvironmentLogger(environment, logger);
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                return (0, tasks_1.addAbortedCheck)(eyes, [environment], ABORTED, environmentLogger);
+            const open = { eyes, environment, driver, logger: environmentLogger };
+            (0, steps_1.addCheckAndClose)(eyes.session, (0, to_environment_key_1.toEnvironmentKey)(environment), {
+                open,
+                upload: { target: baseTargets[index], settings: baseSettings[index], signal, logger: environmentLogger },
+                inputs: {
+                    canFuse: true,
+                    mutability,
+                    signal,
+                    onError: (error, baseEyes) => {
+                        var _a;
+                        environmentLogger.error(`Check on environment with id "${(_a = baseEyes.test.environment) === null || _a === void 0 ? void 0 : _a.environmentId}" failed due to an error`, error);
+                        error.info = { ...error.info, userTestId: eyes.test.userTestId, environment };
+                    },
+                    logger: environmentLogger,
+                },
+                settings: baseSettings[index],
+            });
         });
     };
 }