@applitools/eyes-browser 1.5.17 → 1.5.18

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [1.5.18](https://github.com/Applitools-Dev/sdk/compare/js/eyes-browser@1.5.17...js/eyes-browser@1.5.18) (2025-12-14)
+
+
+### Dependencies
+
+* @applitools/nml-client bumped to 1.11.13
+
+* @applitools/core-base bumped to 1.31.0
+  #### Features
+
+  * Baseline branch fallback list | FLD-3837 ([#3373](https://github.com/Applitools-Dev/sdk/issues/3373)) ([e94bb10](https://github.com/Applitools-Dev/sdk/commit/e94bb10ad6b49322a56e4ce6dfde560b237e9ac0))
+* @applitools/core bumped to 4.54.0
+  #### Features
+
+  * Baseline branch fallback list | FLD-3837 ([#3373](https://github.com/Applitools-Dev/sdk/issues/3373)) ([e94bb10](https://github.com/Applitools-Dev/sdk/commit/e94bb10ad6b49322a56e4ce6dfde560b237e9ac0))
+
+
+
+* @applitools/ec-client bumped to 1.12.15
+
+* @applitools/eyes bumped to 1.36.18
+
+
 ## [1.5.17](https://github.com/Applitools-Dev/sdk/compare/js/eyes-browser@1.5.16...js/eyes-browser@1.5.17) (2025-12-07)
 
 

package/dist/index.js

@@ -22142,7 +22142,7 @@ var require_requests = __commonJS({
         logger.log('Request "openEyes" called with settings', settings);
         const account = await getAccountInfoWithCache({ settings });
         if (account.processKeepaliveIntervalSec) {
-          heartbeat.acquire({
+          settings.processId = heartbeat.acquire({
             eyesServerUrl: settings.eyesServerUrl,
             apiKey: settings.apiKey,
             proxy: settings.proxy,
@@ -22482,6 +22482,9 @@ var require_requests = __commonJS({
           supportedEnvironmentsUrl,
           uploadUrl,
           serverConcurrency: (0, server_concurrency_converter_1.handleConcurrency)(serverConcurrency),
+          scmSettings: {
+            isFallbackBranchListEnabled: res.isFallbackBranchListEnabled
+          },
           ...rest
         };
         logger.mask(result.ufgServer.accessToken);
@@ -23107,6 +23110,8 @@ var require_requests = __commonJS({
         baselineBranchName: settings.baselineBranchName,
         compareWithParentBranch: settings.compareWithParentBranch,
         parentBranchBaselineSavedBefore: settings.gitBranchingTimestamp,
+        branchLookupFallbackList: settings.branchLookupFallbackList,
+        gitBranchName: settings.gitBranchName,
         ignoreBaseline: settings.ignoreBaseline,
         saveDiffs: settings.saveDiffs,
         timeout: settings.abortIdleTestTimeout,
@@ -60278,6 +60283,9 @@ var require_requests_offline = __commonJS({
             sessionConcurrency: -1,
             componentConcurrency: -1
             // unlimited
+          },
+          scmSettings: {
+            isFallbackBranchListEnabled: false
           }
         };
       }
@@ -67327,38 +67335,50 @@ var require_heartbeat = __commonJS({
       const logger = mainLogger.extend(mainLogger, { tags: [`heartbeat-base-${utils34.general.shortid()}`] });
       function stopHeartbeats() {
         logger.log("Stopping heartbeats");
-        isRunning = false;
         if (intervalId) {
           clearInterval(intervalId);
           intervalId = void 0;
+          isRunning = false;
+          processId = utils34.general.guid();
+          logger.log("Generated new processId after expiration:", processId);
         }
       }
       async function startHeartbeats(settings) {
-        if (!isRunning) {
-          processId = utils34.general.guid();
-          isRunning = true;
-          logger.log("Starting heartbeats with new processId:", processId);
-          await requests.sendHeartbeat({ settings: { ...settings, processId }, logger }).catch((error) => {
-            logger.error("Failed to send heartbeat:", error);
-          });
-          intervalId = setIntervalBrowser(async () => {
-            try {
-              await requests.sendHeartbeat({ settings: { ...settings, processId }, logger });
-            } catch (error) {
-              if (error.message === "This process is expired. All its sessions were abandoned") {
-                stopHeartbeats();
-              }
+        await requests.sendHeartbeat({ settings: { ...settings, processId }, logger }).catch((error) => {
+          logger.error("Failed to send heartbeat:", error);
+        });
+        intervalId = setIntervalBrowser(async () => {
+          try {
+            await requests.sendHeartbeat({ settings: { ...settings, processId }, logger });
+          } catch (error) {
+            if (error.message === "This process is expired. All its sessions were abandoned") {
+              logger.log("Heartbeat process expired on server");
+              stopHeartbeats();
             }
-          }, settings.interval);
-          intervalId.unref();
-        }
+          }
+        }, settings.interval);
+        intervalId.unref();
       }
       function acquire(settings) {
         refCount++;
         logger.log("Heartbeat acquired, refCount:", refCount);
-        void startHeartbeats(settings).catch((error) => {
-          logger.error("Failed to start heartbeats:", error);
-        });
+        if (!isRunning) {
+          if (settings.processId && settings.processId === processId) {
+            logger.log("Starting heartbeats with provided processId:", processId);
+          } else if (!settings.processId || settings.processId !== processId) {
+            if (settings.processId && settings.processId !== processId) {
+              logger.log("Provided processId differs from current, using current processId:", processId);
+            } else {
+              processId = utils34.general.guid();
+              logger.log("Starting heartbeats with new processId:", processId);
+            }
+          }
+          isRunning = true;
+          void startHeartbeats(settings).catch((error) => {
+            logger.error("Failed to start heartbeats:", error);
+          });
+        }
+        return processId;
       }
       function release() {
         if (refCount > 0) {
@@ -119577,12 +119597,29 @@ var require_extract_git_info = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.isISODate = exports.extractBranchingTimestamp = exports.extractBuildIdFromCI = exports.extractGitRepo = exports.extractGitBranch = exports.extractLatestCommitInfo = exports.cacheKey = void 0;
+    exports.extractBranchLookupFallbackList = exports.isISODate = exports.extractBranchingTimestamp = exports.extractBuildIdFromCI = exports.extractGitRepo = exports.extractGitBranch = exports.extractLatestCommitInfo = exports.getPrimaryRemoteName = exports.cacheKey = void 0;
     var utils34 = __importStar(require_browser3());
     var fs_1 = __importDefault((init_fs(), __toCommonJS(fs_exports)));
     var path_1 = __importDefault(require_path_browserify());
     var logger_1 = require_browser6();
+    var isDebugMode = () => process.env.RUNNER_DEBUG === "1";
     exports.cacheKey = "default";
+    exports.getPrimaryRemoteName = utils34.general.cachify(async function({ execOptions, logger = (0, logger_1.makeLogger)() }) {
+      const result = await executeWithLog("git remote show", { execOptions, logger });
+      if (result.stderr) {
+        logger.log(`Error during extracting remotes from git`, result.stderr);
+        return "origin";
+      }
+      const remotes = result.stdout.trim().split(/\s+/);
+      const remote = remotes.includes("origin") ? "origin" : remotes[0] || "origin";
+      logger.log(`Primary remote name: ${remote}`);
+      return remote;
+    }, (args) => {
+      var _a;
+      return {
+        cwd: (_a = args[0].execOptions) === null || _a === void 0 ? void 0 : _a.cwd
+      };
+    });
     exports.extractLatestCommitInfo = utils34.general.cachify(async function({ execOptions, logger = (0, logger_1.makeLogger)() }) {
       let result;
       try {
@@ -119607,7 +119644,8 @@ var require_extract_git_info = __commonJS({
       async function extractGithubPullRequestLastCommitSha() {
         var _a, _b, _c;
         if (((_a = process.env.GITHUB_EVENT_NAME) === null || _a === void 0 ? void 0 : _a.startsWith("pull_request")) && process.env.GITHUB_EVENT_PATH) {
-          await executeWithLog(`git fetch origin --depth=2`, { execOptions, logger });
+          const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
+          await executeWithLog(`git fetch ${remoteName} --depth=2`, { execOptions, logger });
           const event = await fs_1.default.promises.readFile(process.env.GITHUB_EVENT_PATH, "utf-8").then(JSON.parse);
           return (_c = (_b = event === null || event === void 0 ? void 0 : event.pull_request) === null || _b === void 0 ? void 0 : _b.head) === null || _c === void 0 ? void 0 : _c.sha;
         }
@@ -119628,7 +119666,10 @@ var require_extract_git_info = __commonJS({
         logger.log(`Extracted current git branch: "${branch}"`);
         return branch;
       }
-    }, () => exports.cacheKey);
+    }, (args) => {
+      var _a, _b, _c;
+      return { cwd: (_b = (_a = args[0]) === null || _a === void 0 ? void 0 : _a.execOptions) === null || _b === void 0 ? void 0 : _b.cwd, ignoreGitBranching: (_c = args[0]) === null || _c === void 0 ? void 0 : _c.ignoreGitBranching };
+    });
     exports.extractGitRepo = utils34.general.cachify(async function({ execOptions, logger = (0, logger_1.makeLogger)() }) {
       const remotes = await extractRemotes();
       logger.log(`Extracted remotes from git: ${remotes}`);
@@ -119668,21 +119709,40 @@ var require_extract_git_info = __commonJS({
     exports.extractBranchingTimestamp = utils34.general.cachify(async function({ branchName, parentBranchName, execOptions, logger = (0, logger_1.makeLogger)() }) {
       var _a;
       logger = logger.extend({ tags: [`extract-branching-timestamp-${utils34.general.shortid()}`] });
+      const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
       const command = `HASH=$(git merge-base ${branchName} ${parentBranchName}) && git show -q --format=%aI $HASH`;
       let result = await executeWithLog(command, { execOptions, logger });
-      for (let i = 0; i < 2; i++) {
-        if (result.stderr) {
-          const [, missingBranch] = (_a = result.stderr.match(/Not a valid object name ([^\s]+)/)) !== null && _a !== void 0 ? _a : [];
-          if (missingBranch) {
-            result = await executeWithLog(`git fetch origin ${missingBranch}:${missingBranch} && ${command}`, {
-              execOptions,
-              logger
-            });
+      if (result.stderr) {
+        const commandWithRemoteRefs = `HASH=$(git merge-base ${remoteName}/${branchName} ${remoteName}/${parentBranchName}) && git show -q --format=%aI $HASH`;
+        result = await executeWithLog(commandWithRemoteRefs, { execOptions, logger });
+      }
+      if (result.stderr) {
+        const remoteBranches = await getAllRemoteBranches({ execOptions, logger });
+        for (let i = 0; i < 2; i++) {
+          if (result.stderr) {
+            const [, missingBranch] = (_a = result.stderr.match(/Not a valid object name ([^\s]+)/)) !== null && _a !== void 0 ? _a : [];
+            if (missingBranch) {
+              const normalizedBranchName = missingBranch.replace(new RegExp(`^${remoteName}/`), "");
+              if (!remoteBranches.has(normalizedBranchName)) {
+                logger.log(`Branch ${missingBranch} not found on remote, skipping fetch`);
+                return void 0;
+              }
+              logger.log(`Fetching missing branch ${missingBranch} from remote`);
+              const command2 = `HASH=$(git merge-base ${branchName} ${parentBranchName}) && git show -q --format=%aI $HASH`;
+              result = await executeWithLog(`git fetch ${remoteName} ${normalizedBranchName}:${normalizedBranchName} --filter=tree:0 && ${command2}`, {
+                execOptions,
+                logger
+              });
+            }
           }
         }
       }
       if (!result.stdout) {
-        result = await executeWithLog(`git fetch origin --unshallow && ${command}`, { execOptions, logger });
+        const command2 = `HASH=$(git merge-base ${branchName} ${parentBranchName}) && git show -q --format=%aI $HASH`;
+        result = await executeWithLog(`git fetch ${remoteName} --unshallow --filter=tree:0 && ${command2}`, {
+          execOptions,
+          logger
+        });
       }
       const timestamp = result.stdout.replace(/\s/g, "");
       if (isISODate2(timestamp)) {
@@ -119691,7 +119751,14 @@ var require_extract_git_info = __commonJS({
       } else {
         logger.log(`Error during extracting merge timestamp: git branching timestamp is an invalid ISO date string: ${timestamp}. stderr: ${result.stderr}, stdout: ${result.stdout}`);
       }
-    }, () => exports.cacheKey);
+    }, (args) => {
+      var _a;
+      return {
+        branchName: args[0].branchName,
+        parentBranchName: args[0].parentBranchName,
+        cwd: (_a = args[0].execOptions) === null || _a === void 0 ? void 0 : _a.cwd
+      };
+    });
     async function executeWithLog(command, { execOptions, logger = (0, logger_1.makeLogger)() } = {
       execOptions: {},
       logger: (0, logger_1.makeLogger)()
@@ -119707,6 +119774,365 @@ var require_extract_git_info = __commonJS({
       return /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\+\d{2}:\d{2})?/.test(str);
     }
     exports.isISODate = isISODate2;
+    async function parallelWithLimit(items, concurrency, fn) {
+      const results = [];
+      for (let i = 0; i < items.length; i += concurrency) {
+        const batch = items.slice(i, i + concurrency);
+        const batchResults = await Promise.all(batch.map(fn));
+        results.push(...batchResults);
+      }
+      return results;
+    }
+    var getAllRemoteBranches = utils34.general.cachify(
+      async function({ execOptions, logger }) {
+        var _a;
+        if (isDebugMode()) {
+          logger.log("[getAllRemoteBranches] Starting git ls-remote to fetch all remote branches...");
+          logger.log("[getAllRemoteBranches] execOptions.cwd:", (execOptions === null || execOptions === void 0 ? void 0 : execOptions.cwd) || "undefined");
+        }
+        try {
+          const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
+          const startTime = Date.now();
+          const result = await executeWithLog(`git ls-remote --heads ${remoteName}`, {
+            execOptions,
+            logger
+          });
+          if (isDebugMode()) {
+            logger.log(`[getAllRemoteBranches] git ls-remote completed in ${Date.now() - startTime}ms`);
+            logger.log("[getAllRemoteBranches] stdout length:", ((_a = result.stdout) === null || _a === void 0 ? void 0 : _a.length) || 0);
+            logger.log("[getAllRemoteBranches] stderr:", result.stderr || "(empty)");
+            logger.log("[getAllRemoteBranches] exit code:", result.code);
+          }
+          const branches = /* @__PURE__ */ new Set();
+          if (result.stdout.trim()) {
+            const lines = result.stdout.split("\n");
+            if (isDebugMode()) {
+              logger.log(`[getAllRemoteBranches] Processing ${lines.length} lines from git ls-remote output`);
+            }
+            lines.forEach((line, index) => {
+              const match = line.match(/refs\/heads\/(.+)$/);
+              if (match) {
+                const branchName = match[1];
+                branches.add(branchName);
+                if (isDebugMode() && index < 5) {
+                  logger.log(`[getAllRemoteBranches] Found branch: ${branchName}`);
+                }
+              }
+            });
+            if (isDebugMode() && lines.length > 5) {
+              logger.log(`[getAllRemoteBranches] ... and ${lines.length - 5} more branches`);
+            }
+          } else {
+            logger.log("[getAllRemoteBranches] WARNING: git ls-remote returned empty output");
+          }
+          logger.log(`[getAllRemoteBranches] \u2713 Found ${branches.size} remote branches via git ls-remote`);
+          if (isDebugMode()) {
+            const branchList = Array.from(branches).slice(0, 20);
+            logger.log("[getAllRemoteBranches] Branch list:", branchList.join(", ") + (branches.size > 20 ? ` ... and ${branches.size - 20} more` : ""));
+          }
+          return branches;
+        } catch (err) {
+          logger.log("[getAllRemoteBranches] \u2717 ERROR: Could not fetch remote branches list");
+          logger.log("[getAllRemoteBranches] Error details:", err);
+          logger.log("[getAllRemoteBranches] Error type:", typeof err);
+          if (err instanceof Error) {
+            logger.log("[getAllRemoteBranches] Error message:", err.message);
+            logger.log("[getAllRemoteBranches] Error stack:", err.stack);
+          }
+          return /* @__PURE__ */ new Set();
+        }
+      },
+      // Custom cache key generator - only cache by cwd, not by logger instance
+      (args) => {
+        var _a;
+        return { cwd: (_a = args[0].execOptions) === null || _a === void 0 ? void 0 : _a.cwd };
+      },
+      5 * 60 * 1e3
+    );
+    async function executeFetchStrategy(isShallow, execOptions, logger) {
+      const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
+      if (isShallow) {
+        logger.log(`Shallow repository detected, unshallowing to enable topology discovery...`);
+        await executeWithLog(`git fetch ${remoteName} --unshallow --filter=tree:0`, {
+          execOptions,
+          logger
+        });
+        logger.log(`Repository unshallowed successfully`);
+      } else {
+        logger.log(`Non-shallow clone detected, fetching all remote branches for topology discovery...`);
+        await executeWithLog(`git fetch ${remoteName} --filter=tree:0`, {
+          execOptions,
+          logger
+        });
+        logger.log(`All remote branches fetched successfully`);
+      }
+    }
+    async function ensureRemoteBranchesAvailable(branchName, isShallow, execOptions, logger) {
+      try {
+        const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
+        const symbolicResult = await executeWithLog(`git rev-parse --abbrev-ref ${branchName}@{upstream} `, {
+          execOptions,
+          logger
+        });
+        const isRemoteBranch = symbolicResult.stdout.trim().startsWith(`${remoteName}/`);
+        if (!isRemoteBranch) {
+          return;
+        }
+        logger.log(`Detected remote branch scenario, fetching ancestor branches...`);
+        await executeWithLog(`git config remote.${remoteName}.fetch "+refs/heads/*:refs/remotes/${remoteName}/*"`, {
+          execOptions,
+          logger
+        });
+        await executeFetchStrategy(isShallow, execOptions, logger);
+        logger.log(`Remote branches fetched successfully for complete ancestor check`);
+      } catch (err) {
+        logger.log("Note: Could not determine if branch is remote, continuing with topology discovery", err);
+      }
+    }
+    exports.extractBranchLookupFallbackList = utils34.general.cachify(async function({ gitBranchName, execOptions, logger = (0, logger_1.makeLogger)(), enableShallowClone = true }) {
+      const functionStartTime = Date.now();
+      logger = logger.extend({ tags: [`extract-branch-fallback-list-${utils34.general.shortid()}`] });
+      logger.log(`[PERF] extractBranchLookupFallbackList started for branch: ${gitBranchName}`);
+      try {
+        const shallowCheckStartTime = Date.now();
+        const shallowCheckResult = await executeWithLog("git rev-parse --is-shallow-repository", {
+          execOptions,
+          logger
+        });
+        logger.log(`[PERF] Shallow check took ${Date.now() - shallowCheckStartTime}ms`);
+        const isShallow = shallowCheckResult.stdout.trim() === "true";
+        if (!enableShallowClone && isShallow) {
+          logger.log("Shallow clone detected and APPLITOOLS_SKIP_BRANCH_LOOKUP_IN_SHALLOW_CLONE is enabled, skipping branch lookup");
+          return void 0;
+        }
+        const ensureRemoteStartTime = Date.now();
+        await ensureRemoteBranchesAvailable(gitBranchName, isShallow, execOptions, logger);
+        logger.log(`[PERF] ensureRemoteBranchesAvailable took ${Date.now() - ensureRemoteStartTime}ms`);
+        const topologyStartTime = Date.now();
+        logger.log(`Discovering ancestor branches using git topology for ${gitBranchName}...`);
+        const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
+        const logResult = await executeWithLog(`git log --first-parent --simplify-by-decoration --format="%D" ${gitBranchName}`, { execOptions, logger });
+        const foundBranches = /* @__PURE__ */ new Set();
+        if (!logResult.stderr && logResult.stdout.trim()) {
+          const rawLines = logResult.stdout.split("\n");
+          for (const line of rawLines) {
+            const refs = line.split(",").map((r) => r.trim());
+            for (const ref of refs) {
+              if (ref.includes("tag:"))
+                continue;
+              const cleanRef = ref.replace("HEAD -> ", "").replace(new RegExp(`^${remoteName}/`), "");
+              if (cleanRef && cleanRef !== gitBranchName && cleanRef !== "HEAD")
+                foundBranches.add(cleanRef);
+            }
+          }
+        }
+        let allBranches = Array.from(foundBranches);
+        logger.log(`[PERF] Topology discovery took ${Date.now() - topologyStartTime}ms`);
+        if (isDebugMode()) {
+          logger.log(`Topology discovered ${allBranches.length} potential ancestor branches: ${allBranches.join(", ")}`);
+        } else {
+          logger.log(`Topology discovered ${allBranches.length} potential ancestor branches`);
+        }
+        const remoteBranchesStartTime = Date.now();
+        if (isDebugMode()) {
+          logger.log("[Remote Filtering] ========================================");
+          logger.log("[Remote Filtering] Starting remote branch filtering...");
+          logger.log("[Remote Filtering] Branches to check:", allBranches.join(", "));
+          logger.log("[Remote Filtering] Number of branches before filtering:", allBranches.length);
+        }
+        try {
+          if (isDebugMode()) {
+            logger.log("[Remote Filtering] Calling getAllRemoteBranches...");
+          }
+          const remoteBranches = await getAllRemoteBranches({ execOptions, logger });
+          if (isDebugMode()) {
+            logger.log("[Remote Filtering] getAllRemoteBranches returned");
+            logger.log("[Remote Filtering] Remote branches size:", remoteBranches.size);
+            const remoteBranchList = Array.from(remoteBranches).slice(0, 20);
+            logger.log("[Remote Filtering] Remote branches:", remoteBranchList.join(", ") + (remoteBranches.size > 20 ? ` ... and ${remoteBranches.size - 20} more` : ""));
+          }
+          if (remoteBranches.size > 0) {
+            const beforeFilter = allBranches.length;
+            if (isDebugMode()) {
+              logger.log("[Remote Filtering] Filtering branches against remote...");
+              allBranches.forEach((branch) => {
+                const exists = remoteBranches.has(branch);
+                logger.log(`[Remote Filtering] Branch "${branch}": ${exists ? "\u2713 EXISTS" : "\u2717 MISSING"} on remote`);
+              });
+            }
+            allBranches = allBranches.filter((branch) => remoteBranches.has(branch));
+            const filtered = beforeFilter - allBranches.length;
+            if (isDebugMode()) {
+              logger.log("[Remote Filtering] Branches after filtering:", allBranches.join(", "));
+              logger.log("[Remote Filtering] Number of branches after filtering:", allBranches.length);
+            }
+            if (filtered > 0) {
+              logger.log(`[Remote Filtering] \u2713 Filtered out ${filtered} branches not found on remote`);
+            } else if (isDebugMode()) {
+              logger.log("[Remote Filtering] No branches were filtered out (all exist on remote)");
+            }
+          } else {
+            logger.log("[Remote Filtering] WARNING: No remote branches found, skipping filter");
+          }
+        } catch (err) {
+          logger.log("[Remote Filtering] \u2717 ERROR: Could not filter by remote branches");
+          if (isDebugMode()) {
+            logger.log("[Remote Filtering] Error details:", err);
+            logger.log("[Remote Filtering] Continuing with all discovered branches");
+          }
+        }
+        logger.log(`[Remote Filtering] [PERF] Remote branch filtering took ${Date.now() - remoteBranchesStartTime}ms`);
+        if (isDebugMode()) {
+          logger.log("[Remote Filtering] ========================================");
+        }
+        const filteringStartTime = Date.now();
+        logger.log(`Filtering out sibling branches to keep only true ancestors...`);
+        const ANCESTOR_CHECK_CONCURRENCY = 10;
+        const ancestorChecks = await parallelWithLimit(allBranches, ANCESTOR_CHECK_CONCURRENCY, async (candidateBranch) => {
+          try {
+            const isAncestorResult = await executeWithLog(`git merge-base --is-ancestor ${candidateBranch} ${gitBranchName}`, {
+              execOptions,
+              logger
+            });
+            if (isAncestorResult.code === 0) {
+              logger.log(`\u2713 ${candidateBranch} is a true ancestor`);
+              return { branch: candidateBranch, isAncestor: true };
+            } else if (isAncestorResult.code === 1) {
+              logger.log(`\u2717 ${candidateBranch} is a sibling, not an ancestor`);
+              return { branch: candidateBranch, isAncestor: false };
+            } else {
+              logger.log(`\u26A0 Could not determine if ${candidateBranch} is an ancestor (exit code: ${isAncestorResult.code}), including it to be safe`);
+              return { branch: candidateBranch, isAncestor: true };
+            }
+          } catch (err) {
+            logger.log(`Error checking if ${candidateBranch} is a true ancestor:`, err);
+            return { branch: candidateBranch, isAncestor: true };
+          }
+        });
+        const trueAncestors = ancestorChecks.filter((result) => result.isAncestor).map((result) => result.branch);
+        logger.log(`[PERF] Sibling filtering took ${Date.now() - filteringStartTime}ms`);
+        logger.log(`Filtered to ${trueAncestors.length} true ancestors: ${trueAncestors.join(", ")}`);
+        const timestampStartTime = Date.now();
+        const branchesWithTimestamps = await Promise.all(trueAncestors.map(async (ancestorBranch) => {
+          const timestamp = await (0, exports.extractBranchingTimestamp)({
+            branchName: gitBranchName,
+            parentBranchName: ancestorBranch,
+            execOptions,
+            logger
+          });
+          return timestamp ? { branchName: ancestorBranch, latestViableTimestamp: timestamp } : null;
+        }));
+        logger.log(`[PERF] Timestamp extraction took ${Date.now() - timestampStartTime}ms`);
+        const validBranches = branchesWithTimestamps.filter((item) => item !== null).sort((a, b) => {
+          const timeDiff = new Date(b.latestViableTimestamp).getTime() - new Date(a.latestViableTimestamp).getTime();
+          if (timeDiff === 0) {
+            return a.branchName.localeCompare(b.branchName);
+          }
+          return timeDiff;
+        });
+        try {
+          const firstCommitResult = await executeWithLog("git rev-list --max-parents=0 HEAD", {
+            execOptions,
+            logger
+          });
+          if (firstCommitResult.stdout.trim()) {
+            const firstCommitHash = firstCommitResult.stdout.trim().split("\n")[0];
+            logger.log(`Found root commit: ${firstCommitHash}`);
+            let branchesContainingRootResult = await executeWithLog(`git branch -r --contains ${firstCommitHash}`, {
+              execOptions,
+              logger
+            });
+            if (!branchesContainingRootResult.stdout.trim()) {
+              logger.log("No remote branches contain root commit, trying local branches");
+              branchesContainingRootResult = await executeWithLog(`git branch --contains ${firstCommitHash}`, {
+                execOptions,
+                logger
+              });
+            }
+            if (branchesContainingRootResult.stdout.trim()) {
+              const branchesContainingRoot = branchesContainingRootResult.stdout.split("\n").map((line) => line.trim()).filter((line) => line && !line.includes("->") && !line.includes("HEAD")).map((line) => line.replace(new RegExp(`^${remoteName}/`), "").replace(/^\* /, ""));
+              const commonRootNames = ["main", "master", "develop", "trunk"];
+              let rootBranch = null;
+              for (const commonName of commonRootNames) {
+                if (branchesContainingRoot.includes(commonName)) {
+                  rootBranch = commonName;
+                  logger.log(`Found root branch using common name: ${rootBranch}`);
+                  break;
+                }
+              }
+              if (!rootBranch && branchesContainingRoot.length > 0) {
+                const branchTimestamps = await Promise.all(branchesContainingRoot.slice(0, 10).map(async (branch) => {
+                  try {
+                    const branchTimestampResult = await executeWithLog(`git log -1 --format=%aI ${branch}`, {
+                      execOptions,
+                      logger
+                    });
+                    return {
+                      branch,
+                      timestamp: branchTimestampResult.stdout.trim()
+                    };
+                  } catch {
+                    return null;
+                  }
+                }));
+                const validTimestamps = branchTimestamps.filter((item) => item !== null && isISODate2(item.timestamp)).sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+                if (validTimestamps.length > 0) {
+                  rootBranch = validTimestamps[0].branch;
+                  logger.log(`Found root branch by oldest timestamp: ${rootBranch}`);
+                }
+              }
+              if (rootBranch && rootBranch !== gitBranchName) {
+                const alreadyIncluded = validBranches.some((b) => b.branchName === rootBranch);
+                if (!alreadyIncluded) {
+                  try {
+                    const isAncestorResult = await executeWithLog(`git merge-base --is-ancestor ${rootBranch} ${gitBranchName}`, {
+                      execOptions,
+                      logger
+                    });
+                    if (isAncestorResult.code === 0) {
+                      logger.log(`Root branch ${rootBranch} is a true ancestor, adding it as final fallback`);
+                      const rootTimestamp = await (0, exports.extractBranchingTimestamp)({
+                        branchName: gitBranchName,
+                        parentBranchName: rootBranch,
+                        execOptions,
+                        logger
+                      });
+                      if (rootTimestamp) {
+                        validBranches.push({
+                          branchName: rootBranch,
+                          latestViableTimestamp: rootTimestamp
+                        });
+                        logger.log(`Added root branch ${rootBranch} with timestamp ${rootTimestamp}`);
+                      }
+                    } else {
+                      logger.log(`Root branch ${rootBranch} is not an ancestor of ${gitBranchName}, skipping`);
+                    }
+                  } catch (err) {
+                    logger.log(`Error checking if root branch ${rootBranch} is an ancestor:`, err);
+                  }
+                } else {
+                  logger.log(`Root branch ${rootBranch} already included in the list`);
+                }
+              }
+            }
+          }
+        } catch (err) {
+          logger.log("Failed to detect and add root branch, continuing without it", err);
+        }
+        logger.log(`[PERF] extractBranchLookupFallbackList completed in ${Date.now() - functionStartTime}ms total`);
+        logger.log("Successfully extracted branch lookup fallback list", JSON.stringify(validBranches));
+        return validBranches.length > 0 ? validBranches : void 0;
+      } catch (err) {
+        logger.log("Error during extracting branch lookup fallback list", err);
+        return void 0;
+      }
+    }, (args) => {
+      var _a;
+      return {
+        gitBranchName: args[0].gitBranchName,
+        cwd: (_a = args[0].execOptions) === null || _a === void 0 ? void 0 : _a.cwd
+      };
+    });
   }
 });
 
@@ -119772,6 +120198,7 @@ var require_open_eyes4 = __commonJS({
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
         var _1, _2, _3, _4, _5;
         logger = logger.extend(mainLogger, { tags: [`eyes-${type}-${utils34.general.shortid()}`] });
+        logger.log(`Opening Eyes in directory "${cwd}"`);
         const settings = { environments: config === null || config === void 0 ? void 0 : config.check.environments, ...config === null || config === void 0 ? void 0 : config.open, ...openSettings };
         const eyesServerSettings = (0, populate_eyes_server_settings_1.populateEyesServerSettings)(settings);
         logger.mask(eyesServerSettings.apiKey);
@@ -119831,6 +120258,7 @@ var require_open_eyes4 = __commonJS({
           }
         }
         const account = await core.getAccountInfo({ settings: eyesServerSettings, logger });
+        await handleBranchFallbackList(account, settings, logger);
         const componentConcurrency = account.serverConcurrency.componentConcurrency;
         settings.sessionConcurrency = handleConcurrency({
           userConcurrency: concurrency,
@@ -119914,6 +120342,31 @@ var require_open_eyes4 = __commonJS({
           }
         }
       };
+      async function handleBranchFallbackList(account, settings, logger) {
+        var _a, _b;
+        const scm = getScmSettings(account.scmSettings);
+        if (!settings.ignoreGitBranching && scm.lookupFallbackList) {
+          logger.log(`Extracting git branch name, ${cwd}`);
+          settings.gitBranchName = await (0, extract_git_info_1.extractGitBranch)({
+            execOptions: { cwd },
+            logger,
+            ignoreGitBranching: settings.ignoreGitBranching
+          });
+          logger.log(`Extracted git branch name: ${settings.gitBranchName}`);
+          (_a = settings.branchName) !== null && _a !== void 0 ? _a : settings.branchName = settings.gitBranchName;
+        } else {
+          logger.log(`Skipping extraction of git branch name as ignoreGitBranching is set to true`);
+        }
+        if (settings.gitBranchName && !settings.ignoreGitBranching && scm.lookupFallbackList) {
+          logger.log(`Extracting branch lookup fallback list for branch "${settings.gitBranchName}, ${cwd}"`);
+          settings.branchLookupFallbackList = await (0, extract_git_info_1.extractBranchLookupFallbackList)({
+            gitBranchName: `${settings.gitBranchName}`,
+            enableShallowClone: (_b = scm.enableShallowClone) !== null && _b !== void 0 ? _b : false,
+            execOptions: { cwd },
+            logger
+          });
+        }
+      }
     }
     exports.makeOpenEyes = makeOpenEyes;
     function refineMissingApiKeyException(error, sdk) {
@@ -119986,6 +120439,23 @@ var require_open_eyes4 = __commonJS({
     function isRealBatchId(batchId) {
       return !!batchId && !batchId.startsWith("generated");
     }
+    function getScmSettings(scmSettings) {
+      var _a, _b;
+      let enableShallowClone = (_a = scmSettings.isShallowCloneEnabled) !== null && _a !== void 0 ? _a : true;
+      let lookupFallbackList = (_b = scmSettings.isFallbackBranchListEnabled) !== null && _b !== void 0 ? _b : false;
+      const envLookupFallbackList = utils34.general.getEnvValue("ENABLE_BRANCH_LOOKUP_FALLBACK_LIST", "boolean");
+      const envShallowClone = utils34.general.getEnvValue("SKIP_BRANCH_LOOKUP_IN_SHALLOW_CLONE", "boolean");
+      if (envLookupFallbackList !== void 0) {
+        lookupFallbackList = envLookupFallbackList;
+      }
+      if (envShallowClone !== void 0) {
+        enableShallowClone = !envShallowClone;
+      }
+      return {
+        lookupFallbackList,
+        enableShallowClone
+      };
+    }
     function handleConcurrency({ userConcurrency, componentConcurrency, useServerConcurrency, shouldPrintConcurrencyWarning, logger }) {
       let sessionConcurrency;
       if (userConcurrency !== void 0 && userConcurrency <= 0) {
@@ -120497,7 +120967,7 @@ var require_package3 = __commonJS({
   "../core/package.json"(exports, module) {
     module.exports = {
       name: "@applitools/core",
-      version: "4.53.2",
+      version: "4.54.0",
       homepage: "https://applitools.com",
       bugs: {
         url: "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -120548,12 +121018,13 @@ var require_package3 = __commonJS({
         "build:bin": "yarn build && sea",
         "build:bin:zip": "zip -j ./bin/core.zip $(find ./bin -type f -not -name '*.zip' -not -name '*.tar.gz' | xargs)",
         "build:bin:tgz": "tar -czf ./bin/core.tar.gz $(find ./bin -type f -not -name '*.zip' -not -name '*.tar.gz' | xargs)",
-        test: "run --top-level mocha './test/**/*.spec.ts' --exclude './test/bin/**' --parallel --jobs ${MOCHA_JOBS:-15} --exit --require ./test/mocha-global-setup.js",
+        test: "run --top-level mocha './test/**/*.spec.ts' --exclude './test/bin/**' --exclude './test/e2e/mocha-sync/**' --parallel --jobs ${MOCHA_JOBS:-15} --exit --require ./test/mocha-global-setup.js",
         "test:local": "MOCHA_OMIT_TAGS=sauce,browserstack run test",
         "test:sauce": "MOCHA_ONLY_TAGS=sauce,browserstack run test",
         "test:bin": "MOCHA_GROUP=bin run --top-level mocha './test/bin/**/*.spec.ts' --parallel --jobs ${MOCHA_JOBS:-15} --require ./test/mocha-global-setup.js",
-        "test:e2e": "MOCHA_GROUP=e2e run --top-level mocha './test/e2e/**/*.spec.ts' --parallel --jobs ${MOCHA_JOBS:-15} --exit --require ./test/mocha-global-setup.js",
+        "test:e2e": "MOCHA_GROUP=e2e run --top-level mocha './test/e2e/**/*.spec.ts' --exclude './test/e2e/mocha-sync/**' --parallel --jobs ${MOCHA_JOBS:-15} --exit --require ./test/mocha-global-setup.js",
         "test:it": "MOCHA_GROUP=it run --top-level mocha './test/it/**/*.spec.ts' --require ./test/mocha-global-setup.js",
+        "test:e2e:sync": "MOCHA_GROUP=e2e SYNC=true run --top-level mocha './test/e2e/mocha-sync/**/*.spec.ts' --exit --require ./test/mocha-global-setup.js",
         "test:unit": "MOCHA_GROUP=unit run --top-level mocha './test/unit/**/*.spec.ts' --require ./test/mocha-global-setup.js",
         setup: "run --top-level browsers:setup && run --top-level xvfb:setup",
         "setup:standalone": "sh -c 'yarn chromedriver --port=4444 --verbose &'"
@@ -127412,7 +127883,7 @@ var require_package4 = __commonJS({
   "../eyes/package.json"(exports, module) {
     module.exports = {
       name: "@applitools/eyes",
-      version: "1.36.17",
+      version: "1.36.18",
       keywords: [
         "applitools",
         "eyes",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/eyes-browser",
-  "version": "1.5.17",
+  "version": "1.5.18",
   "keywords": [
     "applitools",
     "browser",
@@ -48,7 +48,7 @@
     "test": "run --top-level mocha './test/**/*.spec.ts'"
   },
   "dependencies": {
-    "@applitools/eyes": "1.36.17"
+    "@applitools/eyes": "1.36.18"
   },
   "devDependencies": {
     "@types/node": "^12.20.55",