@applitools/core 4.74.1 → 4.75.0

package/dist/tasks/match.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = void 0;
+const abort_error_1 = require("../errors/abort-error");
+const queries_1 = require("./queries");
+/** A check step. While still unstarted, it fuses with a `close` added after it into one `matchAndEnd`. */
+function add(graph, { deps, inputs, labels }) {
+    // After the environment's previous step, so steps reach the backend in order.
+    const after = [(0, queries_1.lastStep)(labels.session, labels.env)];
+    return graph.add({
+        type: 'match',
+        deps: { ...deps, open: (0, queries_1.environmentOpen)(labels) },
+        after,
+        inputs,
+        labels,
+        logger: inputs.logger,
+        run,
+        collapse: successor => successor.type === 'close' && inputs.canFuse
+            ? {
+                type: 'matchAndEnd',
+                inputs: { match: inputs, settings: successor.inputs.settings },
+                labels,
+                logger: inputs.logger,
+                run: runMatchAndEnd,
+            }
+            : undefined,
+    });
+}
+exports.add = add;
+async function run(deps, inputs) {
+    var _a;
+    const baseEyes = deps.open;
+    logMutability(baseEyes, inputs);
+    try {
+        if (((_a = inputs.signal) === null || _a === void 0 ? void 0 : _a.aborted) || !baseEyes.running) {
+            throw new abort_error_1.AbortError('Command "check" was aborted during one of the previous steps');
+        }
+        const target = deps.upload;
+        if (!target)
+            return { asExpected: true };
+        return await baseEyes.match({ target: target.target, settings: target.settings, logger: inputs.logger });
+    }
+    catch (error) {
+        throw reportFailure(baseEyes, inputs, error);
+    }
+}
+async function runMatchAndEnd(deps, { match, settings }) {
+    var _a, _b;
+    const baseEyes = deps.open;
+    logMutability(baseEyes, match);
+    try {
+        if (((_a = match.signal) === null || _a === void 0 ? void 0 : _a.aborted) || !baseEyes.running) {
+            throw new abort_error_1.AbortError('Command "check" was aborted during one of the previous steps');
+        }
+        const target = deps.upload;
+        if (target) {
+            await baseEyes.matchAndEnd({ ...target, settings: { ...target.settings, ...settings }, logger: match.logger });
+        }
+        else {
+            await baseEyes.close({ settings, logger: match.logger });
+        }
+        return { asExpected: true };
+    }
+    catch (error) {
+        throw reportFailure(baseEyes, match, error);
+    }
+    finally {
+        (_b = baseEyes.release) === null || _b === void 0 ? void 0 : _b.call(baseEyes);
+    }
+}
+function logMutability(baseEyes, { mutability, logger }) {
+    var _a;
+    if (!mutability)
+        return;
+    const { eyes } = mutability;
+    void eyes.core.logEvent({
+        settings: {
+            level: 'Notice',
+            event: {
+                type: 'eyes.check',
+                message: 'Assuming mutability for check Target',
+                test: {
+                    checkName: mutability.checkName,
+                    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: (_a = baseEyes.test.environment) === null || _a === void 0 ? void 0 : _a.environmentId,
+                },
+                isNew: baseEyes.test.isNew,
+                resultsUrl: baseEyes.test.resultsUrl,
+            },
+            ...eyes.test.eyesServer,
+        },
+        logger,
+    });
+}
+/** Aborts the session on a failed step and reports the error, returning it for the caller to throw. */
+function reportFailure(baseEyes, inputs, error) {
+    var _a, _b;
+    if (baseEyes.running && !((_a = inputs.signal) === null || _a === void 0 ? void 0 : _a.aborted)) {
+        void baseEyes.abort({ settings: { reason: error }, logger: inputs.logger });
+    }
+    (_b = inputs.onError) === null || _b === void 0 ? void 0 : _b.call(inputs, error, baseEyes);
+    return error;
+}

package/dist/tasks/open.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = void 0;
+const get_base_eyes_1 = require("../classic/get-base-eyes");
+const get_base_eyes_2 = require("../ufg/get-base-eyes");
+const queries_1 = require("./queries");
+/**
+ * An environment's base-session open — the root of its chain, one per environment: the environment's existing
+ * open, or a new one. Lazy until a dependent needs it.
+ */
+function add(graph, { inputs, labels }) {
+    const open = (0, queries_1.environmentOpen)(labels);
+    // A check that runs after close or abort dismissed the open gets a new one.
+    if (open && open.status !== 'dismissed')
+        return open;
+    // Kept by its session: later steps, closes and getResults look it up after it settles.
+    return graph.add({
+        type: 'open',
+        kind: 'lazy',
+        inputs,
+        labels,
+        keep: labels.session,
+        logger: inputs.logger,
+        run,
+    });
+}
+exports.add = add;
+async function run(_deps, { eyes, environment, driver, logger }) {
+    try {
+        return eyes.type === 'ufg'
+            ? await (0, get_base_eyes_2.getBaseEyes)({ eyes: eyes, settings: { environment, driver }, logger })
+            : await (0, get_base_eyes_1.getBaseEyes)({ eyes: eyes, settings: { environment, driver }, logger });
+    }
+    catch (error) {
+        error.info = { ...error.info, userTestId: eyes.test.userTestId, environment };
+        throw error;
+    }
+}

package/dist/tasks/queries.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activeEnvironmentKeys = exports.openedEnvironmentKeys = exports.environmentKeys = exports.lastStep = exports.environmentOpen = exports.queryTasks = void 0;
+const graph_1 = require("./graph");
+// The graph is the session's only state: every task carries `{session, env}` labels, and the session
+// keeps its opens and aborted checks queryable after they settle (everything else leaves the graph once settled).
+// `graph.add` holds each type to its contract, so a query by type can type its results.
+function queryTasks({ session, type, env }) {
+    return graph_1.graph.filter(task => task.type === type && task.labels.session === session && (env === undefined || task.labels.env === env), session);
+}
+exports.queryTasks = queryTasks;
+/** The environment's newest open — every task of the environment rests on it. */
+function environmentOpen({ session, env }) {
+    const opens = queryTasks({ session, type: 'open', env });
+    return opens[opens.length - 1];
+}
+exports.environmentOpen = environmentOpen;
+/** The environment's newest unfinished step — its match, or the recheck after it. */
+function lastStep(session, env) {
+    return [...queryTasks({ session, type: 'match', env }), ...queryTasks({ session, type: 'recheck', env })].find(task => task.dependents.size === 0);
+}
+exports.lastStep = lastStep;
+function environmentKeys(session) {
+    return [...new Set(queryTasks({ session, type: 'open' }).map(task => task.labels.env))];
+}
+exports.environmentKeys = environmentKeys;
+/** The environment keys whose open was demanded, not just speculatively pre-created. */
+function openedEnvironmentKeys(session) {
+    return queryTasks({ session, type: 'open' })
+        .filter(task => task.status !== 'pending' && task.status !== 'dismissed')
+        .map(task => task.labels.env);
+}
+exports.openedEnvironmentKeys = openedEnvironmentKeys;
+/** The environments getResults reports: the opened ones, and those of a check the test was aborted during. */
+function activeEnvironmentKeys(session) {
+    const aborted = queryTasks({ session, type: 'abortedCheck' }).map(task => task.labels.env);
+    return [...new Set([...openedEnvironmentKeys(session), ...aborted])];
+}
+exports.activeEnvironmentKeys = activeEnvironmentKeys;

package/dist/tasks/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tasks/ufg/create-render-target.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = void 0;
+const create_render_target_from_snapshot_1 = require("../../ufg/create-render-target-from-snapshot");
+/**
+ * Processes a ufg snapshot's resources as soon as the check is called, before its session opens: it fills the
+ * UFG client's resource cache, which the next snapshot reads as its skip-list, so an already-fetched (e.g.
+ * ephemeral) resource is not re-requested and the renders stay identical.
+ */
+function add(graph, { inputs, labels }) {
+    return graph.add({ type: 'createRenderTarget', inputs, labels, logger: inputs.logger, run });
+}
+exports.add = add;
+function run(_deps, inputs) {
+    return (0, create_render_target_from_snapshot_1.createRenderTargetFromSnapshot)(inputs);
+}

package/dist/tasks/ufg/recheck.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = void 0;
+const render_1 = require("./render");
+const queries_1 = require("../queries");
+/**
+ * The old-infra retry of a ufg check step: when the backend asks for it, re-checks a mismatch against the
+ * previous browser version before the next step, and stops once a retry fails (the backend then stops
+ * expecting retries). Best-effort: a failed retry must not abort the environment — the primary match
+ * already recorded its step.
+ */
+function add(graph, { deps, inputs, labels }) {
+    return graph.add({
+        type: 'recheck',
+        deps: { ...deps, open: (0, queries_1.environmentOpen)(labels) },
+        inputs,
+        labels,
+        logger: inputs.logger,
+        run,
+    });
+}
+exports.add = add;
+async function run(deps, { render: inputs, disabled: oldInfraRetryDisabled, logger }) {
+    var _a;
+    let result;
+    let baseEyes;
+    try {
+        result = deps.match;
+        baseEyes = deps.open;
+    }
+    catch {
+        return;
+    }
+    if (((_a = inputs.signal) === null || _a === void 0 ? void 0 : _a.aborted) || !baseEyes.running)
+        return;
+    if (!baseEyes.test.shouldRetryWithOldInfra || result.asExpected || oldInfraRetryDisabled.has(baseEyes))
+        return;
+    try {
+        const { target, settings } = await (0, render_1.render)(baseEyes, deps.renderTarget, inputs);
+        settings.oldInfraRetry = true;
+        const retry = await baseEyes.match({ target, settings, logger });
+        if (!retry.asExpected)
+            oldInfraRetryDisabled.add(baseEyes);
+    }
+    catch (error) {
+        oldInfraRetryDisabled.add(baseEyes);
+        logger.warn('Old-infra retry failed; keeping the primary check result', error);
+    }
+}

package/dist/tasks/ufg/render.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.render = exports.add = void 0;
+const to_base_check_settings_1 = require("../../automation/utils/to-base-check-settings");
+const build_accessibility_report_options_1 = require("../../ufg/build-accessibility-report-options");
+const abort_error_1 = require("../../errors/abort-error");
+const upload_target_1 = require("../upload-target");
+const queries_1 = require("../queries");
+/** The slow leg of a ufg check step: render the snapshot, then normalize and upload the result. */
+function add(graph, { deps, inputs, labels }) {
+    return graph.add({
+        type: 'render',
+        deps: { ...deps, open: (0, queries_1.environmentOpen)(labels) },
+        inputs,
+        labels,
+        logger: inputs.logger,
+        run,
+    });
+}
+exports.add = add;
+async function run(deps, inputs) {
+    var _a;
+    const baseEyes = deps.open;
+    if (((_a = inputs.signal) === null || _a === void 0 ? void 0 : _a.aborted) || !baseEyes.running)
+        throw new abort_error_1.AbortError('Command "check" was aborted before rendering');
+    return (0, upload_target_1.uploadTarget)(baseEyes, await render(baseEyes, deps.renderTarget, inputs), inputs.logger);
+}
+async function render(baseEyes, renderTarget, { ufgClient, snapshot, environment, accessibility, signal, logger }) {
+    var _a, _b;
+    const accessibilityReportOptions = accessibility && (0, build_accessibility_report_options_1.buildAccessibilityReportOptions)(accessibility);
+    const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
+        settings: snapshot.settings,
+    });
+    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: { ...environment, environmentId: baseEyes.test.environment.environmentId },
+            uploadUrl: baseEyes.test.uploadUrl,
+            stitchingServiceUrl: baseEyes.test.stitchingServiceUrl,
+            accessibilityReportOptions,
+        },
+        signal,
+        logger,
+    });
+    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: { ...target, isTransformed: true }, settings: checkSettings };
+}
+exports.render = render;

package/dist/tasks/ufg/steps.js

@@ -0,0 +1,51 @@
+"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.addCheckAndClose = exports.addCheck = void 0;
+const graph_1 = require("../graph");
+const openTask = __importStar(require("../open"));
+const createRenderTargetTask = __importStar(require("./create-render-target"));
+const renderTask = __importStar(require("./render"));
+const matchTask = __importStar(require("../match"));
+const recheckTask = __importStar(require("./recheck"));
+const lifecycle_1 = require("../lifecycle");
+/** A check step: its render, then its match after the environment's previous one, then its old-infra recheck. */
+function addCheck(session, env, step) {
+    const labels = { session, env };
+    openTask.add(graph_1.graph, { inputs: step.open, labels });
+    const renderTarget = createRenderTargetTask.add(graph_1.graph, { inputs: step.renderTarget, labels });
+    const upload = renderTask.add(graph_1.graph, { deps: { renderTarget }, inputs: step.render, labels });
+    const match = matchTask.add(graph_1.graph, { deps: { upload }, inputs: step.inputs, labels });
+    if (step.recheck)
+        recheckTask.add(graph_1.graph, { deps: { match, renderTarget }, inputs: step.recheck, labels });
+    return match;
+}
+exports.addCheck = addCheck;
+/** A check step and the close it fuses into: one `matchAndEnd`. */
+function addCheckAndClose(session, env, { settings, ...step }) {
+    addCheck(session, env, step);
+    (0, lifecycle_1.addClose)(session, env, { settings, logger: step.inputs.logger });
+}
+exports.addCheckAndClose = addCheckAndClose;

package/dist/tasks/upload-target.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadTarget = void 0;
+const core_base_1 = require("@applitools/core-base");
+/** Normalizes a step's target and uploads its resources — the tail shared by `upload` and `render`. */
+async function uploadTarget(baseEyes, step, logger) {
+    const { target, settings } = await (0, core_base_1.prepareBaseTarget)({ account: baseEyes.test.account, ...step, logger });
+    return baseEyes.uploadTarget({ target, settings, logger });
+}
+exports.uploadTarget = uploadTarget;

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

@@ -28,16 +28,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeCheckAndClose = void 0;
 const driver_1 = require("@applitools/driver");
-const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
 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/ufg/steps");
 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 build_accessibility_report_options_1 = require("./build-accessibility-report-options");
 function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultEnvironments = [], spec, signal, logger: mainLogger, }) {
     return async function checkAndClose({ target = defaultTarget, settings = {}, logger = mainLogger, } = {}) {
         var _a;
@@ -72,147 +71,43 @@ function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultE
             // 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, _j, _k;
-            const environmentLogger = logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
-            const { target } = snapshot;
+        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)({
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                return (0, tasks_1.addAbortedCheck)(eyes, [environment], 'Command "check" was aborted before rendering', environmentLogger);
+            }
+            const open = { eyes, environment, driver, logger: environmentLogger };
+            (0, steps_1.addCheckAndClose)(eyes.session, (0, to_environment_key_1.toEnvironmentKey)(environment), {
+                open,
+                renderTarget: { ufgClient, snapshot, logger: environmentLogger },
+                render: {
                     ufgClient,
                     snapshot,
-                    logger: environmentLogger,
-                    urlWithCredentials: snapshot.url,
-                });
-                const baseEyes = await eyes.getBaseEyes({ settings: { environment, driver }, logger });
-                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,
-                    });
+                    environment,
                     // 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, ...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,
-                            accessibilityReportOptions,
-                        },
-                        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;
-                    // 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)
-                        (_f = baseTarget.accessibilityReportLocation) !== null && _f !== void 0 ? _f : (baseTarget.accessibilityReportLocation = accessibilityReportOptions.uploadUrl);
-                    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 "${(_g = baseEyes.test.environment) === null || _g === void 0 ? void 0 : _g.environmentId}" was aborted during one of the previous steps`);
-                        throw new abort_error_1.AbortError(`Render on environment with id "${(_h = baseEyes.test.environment) === null || _h === void 0 ? void 0 : _h.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: (_j = baseEyes.test.environment) === null || _j === void 0 ? void 0 : _j.environmentId,
-                                    },
-                                    isNew: baseEyes.test.isNew,
-                                    resultsUrl: baseEyes.test.resultsUrl,
-                                },
-                                ...eyes.test.eyesServer,
-                            },
-                            logger: environmentLogger,
-                        });
-                    }
-                    await baseEyes.checkAndClose({
-                        target: { ...baseTarget, isTransformed: true },
-                        settings: baseSettings,
-                        logger: environmentLogger,
-                    });
-                }
-                catch (error) {
-                    environmentLogger.error(`Render on environment with id "${(_k = baseEyes.test.environment) === null || _k === void 0 ? void 0 : _k.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]);
+                    accessibility: settings.accessibilitySettings
+                        ? { accountOptions: eyes.test.account.accessibilityOptions, runOptions: settings.accessibilityRunOptions }
+                        : undefined,
+                    signal,
+                    logger: environmentLogger,
+                },
+                inputs: {
+                    canFuse: true,
+                    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,
+                },
+            });
         });
     };
 }