@applitools/core 4.74.2 → 4.75.0

package/dist/ufg/check.js

@@ -35,10 +35,9 @@ const utils = __importStar(require("@applitools/utils"));
 const lang = __importStar(require("../lang"));
 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");
-const build_accessibility_report_options_1 = require("./build-accessibility-report-options");
+const tasks_1 = require("../tasks");
+const steps_1 = require("../tasks/ufg/steps");
 function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironments = [], spec, signal, logger: mainLogger, }) {
     // Sessions whose old-infra retry chain has ended: once a retry doesn't confirm an old-infra match,
     // the backend stops expecting retries, so we must stop sending them. baseEyes is cached per
@@ -78,183 +77,48 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
             // TODO (amit)
             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;
-            const environmentLogger = logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
-            const { target } = snapshot;
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            return (0, tasks_1.addAbortedCheck)(eyes, uniqueEnvironments, 'Command "check" was aborted before rendering', logger);
+        }
+        logInvalidSettings(logger, settings);
+        // Only request a report when the check configures an accessibility standard.
+        const accessibility = settings.accessibilitySettings
+            ? { accountOptions: eyes.test.account.accessibilityOptions, runOptions: settings.accessibilityRunOptions }
+            : undefined;
+        const mutability = settings.assumesMutability ? { eyes, checkName: settings.name } : undefined;
+        snapshots.forEach((snapshot, i) => {
             const environment = uniqueEnvironments[i];
+            const environmentLogger = eyes.getEnvironmentLogger(environment, logger);
             if (utils.types.has(environment, 'name') && environment.name === 'edge') {
                 environmentLogger.console.log(chalk_1.default.yellow(lang.edgeUfgEnvironmentDeprecatedWarning));
             }
-            try {
-                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                    environmentLogger.warn('Command "check" was aborted before rendering');
-                    throw new abort_error_1.AbortError('Command "check" was aborted before rendering');
-                }
-                if (utils.types.has(environment, 'iosDeviceInfo') || utils.types.has(environment, 'androidDeviceInfo')) {
-                    environment.type = utils.types.has(target, 'cdt') ? 'web' : 'native';
-                }
-                const renderTargetPromise = (0, create_render_target_from_snapshot_1.createRenderTargetFromSnapshot)({
-                    ufgClient,
-                    snapshot,
-                    logger: environmentLogger,
-                    urlWithCredentials: snapshot.url,
-                });
-                const baseEyes = await eyes.getBaseEyes({ settings: { environment, driver }, logger: environmentLogger });
-                try {
-                    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                        environmentLogger.warn('Command "check" was aborted before rendering');
-                        throw new abort_error_1.AbortError('Command "check" was aborted before rendering');
-                    }
-                    else if (!baseEyes.running) {
-                        environmentLogger.warn(`Render 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(`Render on environment with id "${(_b = baseEyes.test.environment) === null || _b === void 0 ? void 0 : _b.environmentId}" was aborted during one of the previous steps`);
-                    }
-                    const renderTarget = await renderTargetPromise;
-                    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                        environmentLogger.warn('Command "check" was aborted before rendering');
-                        throw new abort_error_1.AbortError('Command "check" was aborted before rendering');
-                    }
-                    else if (!baseEyes.running) {
-                        environmentLogger.warn(`Render on environment with id "${(_c = baseEyes.test.environment) === null || _c === void 0 ? void 0 : _c.environmentId}" was aborted during one of the previous steps`);
-                        throw new abort_error_1.AbortError(`Render on environment with id "${(_d = baseEyes.test.environment) === null || _d === void 0 ? void 0 : _d.environmentId}" was aborted during one of the previous steps`);
-                    }
-                    const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
-                        settings: snapshot.settings,
-                    });
-                    const renderForCheck = async (env) => {
-                        var _a, _b;
-                        // Only request a report when the check configures an accessibility standard.
-                        const accessibilityReportOptions = settings.accessibilitySettings
-                            ? (0, build_accessibility_report_options_1.buildAccessibilityReportOptions)({
-                                accountOptions: eyes.test.account.accessibilityOptions,
-                                runOptions: settings.accessibilityRunOptions,
-                            })
-                            : undefined;
-                        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,
-                                accessibilityReportOptions,
-                            },
-                            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;
-                        // Fall back to the minted upload URL when the render result carries no report location.
-                        if (accessibilityReportOptions === null || accessibilityReportOptions === void 0 ? void 0 : accessibilityReportOptions.uploadUrl)
-                            (_b = target.accessibilityReportLocation) !== null && _b !== void 0 ? _b : (target.accessibilityReportLocation = accessibilityReportOptions.uploadUrl);
-                        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 "${(_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({
-                            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: (_g = baseEyes.test.environment) === null || _g === void 0 ? void 0 : _g.environmentId,
-                                    },
-                                    isNew: baseEyes.test.isNew,
-                                    resultsUrl: baseEyes.test.resultsUrl,
-                                },
-                                ...eyes.test.eyesServer,
-                            },
-                            logger: environmentLogger,
-                        });
-                    }
-                    try {
-                        logInvalidSettings(logger, settings);
-                    }
-                    catch (err) {
-                        logger.log('Failed to log invalid check settings', err);
-                    }
-                    await baseEyes.check({
-                        target: { ...baseTarget, isTransformed: true },
-                        settings: baseSettings,
-                        logger: environmentLogger,
-                        // When the backend enabled old-infra retry, re-check a mismatch against the previous
-                        // browser version in the SAME step slot (so it reaches the backend before the next
-                        // step's check), and stop once a retry fails — at that point the backend treats the
-                        // session as non-infra and stops expecting retries. Best-effort: a failed retry render
-                        // must not abort the environment, since the primary check already recorded its step.
-                        followup: baseEyes.test.shouldRetryWithOldInfra
-                            ? async (result, recheck) => {
-                                if (result.asExpected || oldInfraRetryDisabled.has(baseEyes))
-                                    return;
-                                const oldInfraEnvironment = (0, to_old_infra_environment_1.toOldInfraEnvironment)(environment);
-                                if (!oldInfraEnvironment)
-                                    return;
-                                try {
-                                    const { target, settings } = await renderForCheck(oldInfraEnvironment);
-                                    settings.oldInfraRetry = true;
-                                    const retry = await recheck({ ...target, isTransformed: true }, settings);
-                                    if (!retry.asExpected)
-                                        oldInfraRetryDisabled.add(baseEyes);
-                                }
-                                catch (error) {
-                                    oldInfraRetryDisabled.add(baseEyes);
-                                    environmentLogger.warn('Old-infra retry failed; keeping the primary check result', error);
-                                }
-                            }
-                            : undefined,
-                    });
-                }
-                catch (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 } });
-                }
-            }
-            catch (error) {
-                environmentLogger.error(`Environment with id ${environment.environmentId} failed before rendering started due to an error`, error);
-                error.info = { ...error.info, userTestId: eyes.test.userTestId, environment };
-                throw error;
-            }
-        });
-        uniqueEnvironments.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 open = { eyes, environment, driver, logger: environmentLogger };
+            const renderInputs = { ufgClient, snapshot, environment, accessibility, signal, logger: environmentLogger };
+            const oldInfraEnvironment = (0, to_old_infra_environment_1.toOldInfraEnvironment)(environment);
+            (0, steps_1.addCheck)(eyes.session, key, {
+                open,
+                renderTarget: { ufgClient, snapshot, logger: environmentLogger },
+                render: renderInputs,
+                recheck: oldInfraEnvironment
+                    ? {
+                        render: { ...renderInputs, environment: oldInfraEnvironment },
+                        disabled: oldInfraRetryDisabled,
+                        logger: environmentLogger,
+                    }
+                    : undefined,
+                inputs: {
+                    canFuse: !oldInfraEnvironment,
+                    mutability,
+                    signal,
+                    onError: (error, baseEyes) => {
+                        var _a;
+                        environmentLogger.error(`Render 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,
+                },
+            });
         });
     };
 }

package/dist/ufg/get-base-eyes.js

@@ -1,78 +1,40 @@
 "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.makeGetBaseEyes = void 0;
-const utils = __importStar(require("@applitools/utils"));
+exports.getBaseEyes = void 0;
 const report_kobiton_1 = require("../automation/utils/report-kobiton");
-function makeGetBaseEyes({ settings: defaultSettings, eyes, logger: mainLogger, }) {
-    const getBaseEyesWithCache = utils.general.wrap(getBaseEyes, (getBaseEyes, options) => {
-        const key = JSON.stringify(options.settings.environment);
-        let item = eyes.storage.get(key);
-        if (!item) {
-            item = { eyes: utils.promises.makeControlledPromise(), jobs: [] };
-            eyes.storage.set(key, item);
-        }
-        if (!item.eyes.settled)
-            item.eyes.resolve(getBaseEyes(options));
-        return item.eyes;
+async function getBaseEyes({ eyes, settings, logger, }) {
+    var _a, _b;
+    const defaultSettings = eyes.openSettings;
+    logger.log(`Command "getBaseEyes" is called with settings`, settings);
+    const ufgClient = await eyes.core.getUFGClient({
+        settings: {
+            ...eyes.test.ufgServer,
+            eyesServerUrl: eyes.test.eyesServer.eyesServerUrl,
+            apiKey: eyes.test.eyesServer.apiKey,
+        },
+        logger,
     });
-    return getBaseEyesWithCache;
-    async function getBaseEyes({ settings, logger = mainLogger, }) {
-        var _a, _b;
-        logger = logger.extend(mainLogger);
-        logger.log(`Command "getBaseEyes" is called with settings`, settings);
-        const ufgClient = await eyes.core.getUFGClient({
-            settings: {
-                ...eyes.test.ufgServer,
-                eyesServerUrl: eyes.test.eyesServer.eyesServerUrl,
-                apiKey: eyes.test.eyesServer.apiKey,
-            },
-            logger,
-        });
-        const environment = await ufgClient.getActualEnvironment({
-            settings: { environment: settings.environment },
-            logger,
-        });
-        const baseEyes = await eyes.core.base.openEyes({
-            settings: {
-                ...defaultSettings,
-                fallbackBaselineId: (_b = (_a = settings.environment) === null || _a === void 0 ? void 0 : _a.fallbackBaselineId) !== null && _b !== void 0 ? _b : defaultSettings.fallbackBaselineId,
-                environment: {
-                    ...defaultSettings.environment,
-                    ...environment,
-                    os: settings.environment.os,
-                    displayOs: settings.environment.displayOs,
-                    hostingApp: settings.environment.hostingApp,
-                    displayHostingApp: settings.environment.displayHostingApp,
-                    properties: settings.environment.properties,
-                },
+    const environment = await ufgClient.getActualEnvironment({
+        settings: { environment: settings.environment },
+        logger,
+    });
+    const baseEyes = await eyes.core.base.openEyes({
+        settings: {
+            ...defaultSettings,
+            fallbackBaselineId: (_b = (_a = settings.environment) === null || _a === void 0 ? void 0 : _a.fallbackBaselineId) !== null && _b !== void 0 ? _b : defaultSettings.fallbackBaselineId,
+            environment: {
+                ...defaultSettings.environment,
+                ...environment,
+                os: settings.environment.os,
+                displayOs: settings.environment.displayOs,
+                hostingApp: settings.environment.hostingApp,
+                displayHostingApp: settings.environment.displayHostingApp,
+                properties: settings.environment.properties,
             },
-            logger,
-        });
-        void (0, report_kobiton_1.reportKobiton)({ driver: settings.driver, settings: baseEyes.test, logger });
-        return baseEyes;
-    }
+        },
+        logger,
+    });
+    void (0, report_kobiton_1.reportKobiton)({ driver: settings.driver, settings: baseEyes.test, logger });
+    return baseEyes;
 }
-exports.makeGetBaseEyes = makeGetBaseEyes;
+exports.getBaseEyes = getBaseEyes;

package/dist/ufg/open-eyes.js

@@ -25,7 +25,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeOpenEyes = void 0;
 const driver_1 = require("@applitools/driver");
-const get_base_eyes_1 = require("./get-base-eyes");
 const check_1 = require("./check");
 const check_and_close_1 = require("./check-and-close");
 const close_1 = require("../automation/close");
@@ -33,16 +32,19 @@ const abort_1 = require("../automation/abort");
 const get_results_1 = require("../automation/get-results");
 const extract_default_environment_1 = require("./utils/extract-default-environment");
 const verify_environment_info_1 = require("./utils/verify-environment-info");
+const tasks_1 = require("../tasks");
+const uniquify_environments_1 = require("../automation/utils/uniquify-environments");
 const abort_controller_1 = require("abort-controller");
 const utils = __importStar(require("@applitools/utils"));
 const register_default_scripts_1 = require("./utils/register-default-scripts");
+const make_environment_loggers_1 = require("../automation/utils/make-environment-loggers");
 function makeOpenEyes({ core, spec, logger: mainLogger }) {
-    return async function openEyes({ target, settings, storage = new Map(), logger = mainLogger, }) {
-        var _a, _b, _c, _d;
+    return async function openEyes({ target, settings, session = {}, logger = mainLogger, }) {
+        var _a, _b, _c, _d, _e;
         logger = logger.extend(mainLogger);
-        logger.log(`Command "openEyes" is called with ${target ? 'default driver' : ''}`, ...(settings ? ['and settings', settings] : []), storage.size > 0 ? 'and default eyes storage' : '');
+        logger.log(`Command "openEyes" is called with ${target ? 'default driver' : ''}`, ...(settings ? ['and settings', settings] : []), (0, tasks_1.activeEnvironmentKeys)(session).length > 0 ? 'and existing sessions' : '');
         const driver = target && (await (0, driver_1.makeDriver)({ spec, driver: target, logger }));
-        if (driver && storage.size === 0) {
+        if (driver && (0, tasks_1.activeEnvironmentKeys)(session).length === 0) {
             const environment = await driver.getEnvironment();
             if (((_a = settings.environment) === null || _a === void 0 ? void 0 : _a.viewportSize) && !environment.isMobile) {
                 await driver.setViewportSize(settings.environment.viewportSize);
@@ -68,7 +70,7 @@ function makeOpenEyes({ core, spec, logger: mainLogger }) {
             logger,
         });
         await (0, verify_environment_info_1.verifyEnvironmentsInfo)({ environments: (_d = settings.environments) !== null && _d !== void 0 ? _d : [], ufgClient });
-        return utils.general.extend({}, eyes => {
+        const eyes = utils.general.extend({}, eyes => {
             var _a, _b, _c, _d;
             return {
                 type: 'ufg',
@@ -86,8 +88,9 @@ function makeOpenEyes({ core, spec, logger: mainLogger }) {
                     account,
                 },
                 running: true,
-                storage,
-                getBaseEyes: (0, get_base_eyes_1.makeGetBaseEyes)({ settings, eyes, logger }),
+                session,
+                getEnvironmentLogger: (0, make_environment_loggers_1.makeEnvironmentLoggers)(),
+                openSettings: settings,
                 check: (0, check_1.makeCheck)({ eyes, target: driver, environments, spec, signal, logger }),
                 checkAndClose: (0, check_and_close_1.makeCheckAndClose)({ eyes, target: driver, environments, spec, signal, logger }),
                 close: (0, close_1.makeClose)({ eyes, driver, logger }),
@@ -95,6 +98,9 @@ function makeOpenEyes({ core, spec, logger: mainLogger }) {
                 getResults: (0, get_results_1.makeGetResults)({ eyes, logger }),
             };
         });
+        const declared = (0, uniquify_environments_1.uniquifyEnvironments)(((_e = settings.environments) === null || _e === void 0 ? void 0 : _e.length) ? settings.environments : environments);
+        (0, tasks_1.declareOpens)(eyes, declared, driver, logger);
+        return eyes;
     };
 }
 exports.makeOpenEyes = makeOpenEyes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "4.74.2",
+  "version": "4.75.0",
   "homepage": "https://applitools.com",
   "license": "SEE LICENSE IN LICENSE",
   "author": {
@@ -55,19 +55,20 @@
     "test:ios-simulator": "MOCHA_ONLY_TAGS=ios-simulator MOCHA_GROUP=ios-simulator run --top-level mocha ./test/e2e/classic/webview.spec.ts --exit --require ./test/mocha-global-setup.js"
   },
   "dependencies": {
-    "@applitools/core-base": "1.41.5",
+    "@applitools/core-base": "1.42.0",
     "@applitools/dom-capture": "11.8.11",
     "@applitools/dom-snapshot": "4.18.9",
     "@applitools/driver": "1.26.15",
-    "@applitools/ec-client": "1.12.56",
+    "@applitools/ec-client": "1.12.57",
     "@applitools/image": "1.3.5",
     "@applitools/logger": "2.3.3",
-    "@applitools/nml-client": "1.12.12",
+    "@applitools/nml-client": "1.12.13",
     "@applitools/req": "1.11.7",
     "@applitools/screenshoter": "3.12.37",
     "@applitools/snippets": "2.9.10",
     "@applitools/socket": "1.3.19",
-    "@applitools/ufg-client": "1.25.1",
+    "@applitools/task-manager": "1.0.0",
+    "@applitools/ufg-client": "1.26.0",
     "@applitools/utils": "1.15.3",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",

package/types/automation/abort.d.ts

@@ -1,4 +1,4 @@
-import type { Eyes, AbortSettings, Environment } from './types';
+import type { Eyes, AbortSettings } from './types';
 import { type Logger } from '@applitools/logger';
 import { type AbortController } from 'abort-controller';
 import { type Driver, type SpecType } from '@applitools/driver';
@@ -6,10 +6,9 @@ type Options<TSpec extends SpecType> = {
     eyes: Eyes<TSpec>;
     driver?: Driver<TSpec>;
     controller: AbortController;
-    environments?: Environment[];
     logger: Logger;
 };
-export declare function makeAbort<TSpec extends SpecType>({ eyes, driver, controller, environments: defaultEnvironments, logger: mainLogger, }: Options<TSpec>): ({ settings, logger, }?: {
+export declare function makeAbort<TSpec extends SpecType>({ eyes, driver, controller, logger: mainLogger }: Options<TSpec>): ({ settings, logger, }?: {
     settings?: AbortSettings | undefined;
     logger?: Logger | undefined;
 }) => Promise<void>;

package/types/automation/close.d.ts

@@ -1,13 +1,12 @@
-import type { Eyes, CloseSettings, Environment } from '../ufg/types';
+import type { Eyes, CloseSettings } from './types';
 import { type Logger } from '@applitools/logger';
 import { type Driver, type SpecType } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     eyes: Eyes<TSpec>;
     driver?: Driver<TSpec>;
-    environments?: Environment[];
     logger: Logger;
 };
-export declare function makeClose<TSpec extends SpecType>({ eyes, driver, environments: defaultEnvironments, logger: mainLogger, }: Options<TSpec>): ({ settings, logger, }?: {
+export declare function makeClose<TSpec extends SpecType>({ eyes, driver, logger: mainLogger }: Options<TSpec>): ({ settings, logger, }?: {
     settings?: CloseSettings | undefined;
     logger?: Logger | undefined;
 }) => Promise<void>;

package/types/automation/types.d.ts

@@ -1,10 +1,12 @@
-import type { MaybeArray, Size, Region, ControlledPromise } from '@applitools/utils';
+import type { MaybeArray, Size, Region } from '@applitools/utils';
 import type * as BaseCore from '@applitools/core-base/types';
 import { type SpecType, type Driver, type ElementReference, type ContextReference } from '@applitools/driver';
 import { type NMLClient, type NMLClientSettings } from '@applitools/nml-client';
 import { type Logger } from '@applitools/logger';
 import type { FigmaOptions } from '../figma/types';
+import type { Session } from '../tasks';
 export type * from '@applitools/core-base/types';
+export type { Session } from '../tasks';
 export type DriverTarget<TSpec extends SpecType> = TSpec['driver'] | Driver<TSpec>;
 export type Target<TSpec extends SpecType> = DriverTarget<TSpec> | BaseCore.Target;
 export interface DesktopBrowserEnvironment {
@@ -72,7 +74,8 @@ export interface Core<TSpec extends SpecType> extends Omit<BaseCore.Core, 'openE
     openEyes(options: {
         target?: DriverTarget<TSpec>;
         settings: BaseCore.OpenSettings;
-        storage?: EyesStorage;
+        /** Shares the test's identity with another typed eyes of the same test. @internal */
+        session?: Session;
         logger?: Logger;
     }): Promise<Eyes<TSpec>>;
     locate<TLocator extends string>(options: {
@@ -91,13 +94,15 @@ export interface Core<TSpec extends SpecType> extends Omit<BaseCore.Core, 'openE
         logger?: Logger;
     }): Promise<string[]>;
 }
-export interface Eyes<TSpec extends SpecType> extends Omit<BaseCore.Eyes, 'core' | 'check' | 'checkAndClose'> {
+export interface Eyes<TSpec extends SpecType> extends Pick<BaseCore.Eyes, 'test' | 'running'> {
+    readonly type: 'classic' | 'ufg';
     readonly core: Core<TSpec>;
-    readonly storage: EyesStorage;
-    getBaseEyes(options: {
-        settings: GetBaseEyesSettings<TSpec>;
-        logger?: Logger;
-    }): Promise<BaseCore.Eyes>;
+    /** The test's identity in the task graph — the graph holds its state. @internal */
+    readonly session: Session;
+    /** Tags each environment's logs alike across its open and checks. @internal */
+    getEnvironmentLogger(environment: Environment, logger: Logger): Logger;
+    /** The settings each environment's base session opens with. @internal */
+    readonly openSettings: BaseCore.OpenSettings;
     check(options?: {
         target?: Target<TSpec>;
         settings?: CheckSettings<TSpec>;
@@ -121,14 +126,6 @@ export interface Eyes<TSpec extends SpecType> extends Omit<BaseCore.Eyes, 'core'
         logger?: Logger;
     }): Promise<TestResult[]>;
 }
-export type EyesStorage = Map<string, {
-    eyes: ControlledPromise<BaseCore.Eyes>;
-    jobs: Promise<void>[];
-}>;
-export interface GetBaseEyesSettings<TSpec extends SpecType> {
-    environment: Environment;
-    driver?: Driver<TSpec>;
-}
 export type LazyLoadOptions = {
     scrollLength?: number;
     waitingTime?: number;

package/types/automation/utils/make-environment-loggers.d.ts

@@ -0,0 +1,3 @@
+import type { Environment } from '../types';
+import type { Logger } from '@applitools/logger';
+export declare function makeEnvironmentLoggers(): (environment: Environment, logger: Logger) => Logger;

package/types/classic/get-base-eyes.d.ts

@@ -1,14 +1,10 @@
-import type { Eyes, GetBaseEyesSettings, OpenSettings } from './types';
+import type { Eyes } from './types';
 import type { Eyes as BaseEyes } from '@applitools/core-base';
 import { type SpecType } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
-type Options<TSpec extends SpecType> = {
-    settings: OpenSettings;
+import type { OpenInputs } from '../tasks/types';
+export declare function getBaseEyes<TSpec extends SpecType>({ eyes, settings, logger, }: {
     eyes: Eyes<TSpec>;
+    settings: Pick<OpenInputs, 'environment' | 'driver'>;
     logger: Logger;
-};
-export declare function makeGetBaseEyes<TSpec extends SpecType>({ settings: defaultSettings, eyes, logger: mainLogger, }: Options<TSpec>): ({ settings, logger, }: {
-    settings: GetBaseEyesSettings<TSpec>;
-    logger?: Logger | undefined;
-}) => Promise<BaseEyes>;
-export {};
+}): Promise<BaseEyes>;

package/types/classic/open-eyes.d.ts

@@ -1,15 +1,16 @@
-import type { DriverTarget, Core, Eyes, EyesStorage, OpenSettings } from './types';
+import type { DriverTarget, Core, Eyes, OpenSettings } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
+import { type Session } from '../tasks';
 type Options<TSpec extends SpecType> = {
     core: Core<TSpec>;
     spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: mainLogger }: Options<TSpec>): ({ target, settings, storage, logger, }: {
+export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: mainLogger }: Options<TSpec>): ({ target, settings, session, logger, }: {
     target?: DriverTarget<TSpec> | undefined;
     settings: OpenSettings;
-    storage?: EyesStorage | undefined;
+    session?: object | undefined;
     logger?: Logger | undefined;
 }) => Promise<Eyes<TSpec>>;
 export {};

package/types/classic/types.d.ts

@@ -7,7 +7,7 @@ export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec>
     openEyes(options: {
         target?: AutomationCore.DriverTarget<TSpec>;
         settings: OpenSettings;
-        storage?: AutomationCore.EyesStorage;
+        session?: AutomationCore.Session;
         logger?: Logger;
     }): Promise<Eyes<TSpec>>;
 }

package/types/classic/utils/capture.d.ts

@@ -0,0 +1,21 @@
+import type { CheckSettings, Eyes, Environment, ExactEnvironment } from '../types';
+import type { Target as BaseTarget, CheckSettings as BaseCheckSettings } from '@applitools/core-base';
+import { type Logger } from '@applitools/logger';
+import type { SpecType, Driver } from '@applitools/driver';
+export type Captured = {
+    baseTarget: BaseTarget;
+    baseSetting: BaseCheckSettings;
+    exactEnvironment: ExactEnvironment;
+};
+type DriverEnvironment = Awaited<ReturnType<Driver<SpecType>['getEnvironment']>>;
+/** Whether the capture keeps `environment` as its exact environment, at the same index. */
+export declare function isCapturedAsRequested(settings: CheckSettings<SpecType>, driverEnvironment: DriverEnvironment, environment: Environment): boolean;
+/**
+ * create base targets (array of screenshots) and base settings (array of check settings) for each environment
+ */
+export declare function generateBaseScreenshotsAndSettings<TSpec extends SpecType>(settings: CheckSettings<TSpec>, uniqueEnvironments: Environment[], eyes: Eyes<TSpec>, logger: Logger, driver: Driver<TSpec>): Promise<{
+    baseTarget: BaseTarget;
+    baseSetting: BaseCheckSettings;
+    exactEnvironment: ExactEnvironment;
+}[]>;
+export {};

package/types/tasks/abort.d.ts

@@ -0,0 +1,11 @@
+import type { AbortInputs, Labels, Graph } from './types';
+/**
+ * Aborts the environment's session as soon as it is open, without waiting for its steps (they read the
+ * abort signal), unless an abort is already queued. A pending close or matchAndEnd still gets it; core-base ends a
+ * session only once. Kind `dismiss`: if the open is still lazy (nothing needed it), it's discarded and no session
+ * opens.
+ */
+export declare function add(graph: Graph, { inputs, labels }: {
+    inputs: AbortInputs;
+    labels: Labels;
+}): import("@applitools/task-manager").Task<void, AbortInputs, Labels>;