@applitools/eyes-browser 1.6.22 → 1.6.24

package/dist/index.js

@@ -11968,7 +11968,7 @@ var require_browser_process = __commonJS({
     init_buffer();
     init_setInterval();
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.sh = exports.executeProcess = exports.executeAndControlProcess = exports.execute = void 0;
+    exports.sampleProcessTreeMemory = exports.sh = exports.executeProcess = exports.executeAndControlProcess = exports.execute = void 0;
     var executionOutput = {
       stdout: "",
       stderr: "process execution is not supported in browser environment",
@@ -11997,6 +11997,10 @@ var require_browser_process = __commonJS({
       return executionOutput;
     }
     exports.sh = sh;
+    async function sampleProcessTreeMemory(_rootPid, _options = {}) {
+      return null;
+    }
+    exports.sampleProcessTreeMemory = sampleProcessTreeMemory;
   }
 });
 
@@ -18932,6 +18936,71 @@ var require_formatter = __commonJS({
   }
 });
 
+// ../logger/dist/log-buffer.js
+var require_log_buffer = __commonJS({
+  "../logger/dist/log-buffer.js"(exports) {
+    "use strict";
+    init_global();
+    init_process();
+    init_setImmediate();
+    init_buffer();
+    init_setInterval();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.__resetLogBufferForTests = exports.isLogBufferActive = exports.disableLogBuffer = exports.onLogBufferFull = exports.consumeLogBuffer = exports.appendToLogBuffer = void 0;
+    var LOG_BUFFER_MAX_ENTRIES = 5e4;
+    var LOG_BUFFER_MAX_CHARS = 8e6;
+    var logBuffer = [];
+    var logBufferChars = 0;
+    var onFull;
+    var ANSI_REGEX = /\x1b\[[0-9;]*m/g;
+    function appendToLogBuffer(line) {
+      if (!logBuffer)
+        return;
+      logBuffer.push(line);
+      logBufferChars += line.length;
+      if (logBuffer.length > LOG_BUFFER_MAX_ENTRIES || logBufferChars > LOG_BUFFER_MAX_CHARS) {
+        if (onFull)
+          onFull();
+        else {
+          const dropped = logBuffer.shift();
+          if (dropped)
+            logBufferChars -= dropped.length;
+        }
+      }
+    }
+    exports.appendToLogBuffer = appendToLogBuffer;
+    function consumeLogBuffer() {
+      if (!logBuffer)
+        return "";
+      const text = logBuffer.length ? logBuffer.join("\n") + "\n" : "";
+      logBuffer = [];
+      logBufferChars = 0;
+      return text.replace(ANSI_REGEX, "");
+    }
+    exports.consumeLogBuffer = consumeLogBuffer;
+    function onLogBufferFull(cb) {
+      onFull = cb;
+    }
+    exports.onLogBufferFull = onLogBufferFull;
+    function disableLogBuffer() {
+      logBuffer = void 0;
+      logBufferChars = 0;
+      onFull = void 0;
+    }
+    exports.disableLogBuffer = disableLogBuffer;
+    function isLogBufferActive() {
+      return logBuffer !== void 0;
+    }
+    exports.isLogBufferActive = isLogBufferActive;
+    function __resetLogBufferForTests() {
+      logBuffer = [];
+      logBufferChars = 0;
+      onFull = void 0;
+    }
+    exports.__resetLogBufferForTests = __resetLogBufferForTests;
+  }
+});
+
 // ../logger/dist/handler-console.js
 var require_handler_console = __commonJS({
   "../logger/dist/handler-console.js"(exports) {
@@ -19511,50 +19580,58 @@ var require_printer = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.makePrinter = void 0;
     var log_level_1 = require_log_level();
+    var log_buffer_1 = require_log_buffer();
     function makePrinter({ handler, level = log_level_1.LogLevel.silent, format, masks, maskLog }) {
       var _a;
       const formatter = (_a = format === null || format === void 0 ? void 0 : format.formatter) !== null && _a !== void 0 ? _a : (chunks, options) => ({ chunks, options, isRaw: true });
       return { debug, log, info: log, warn, error, fatal, verbose: log };
+      function emit(threshold, levelName, messages) {
+        const gated = level < threshold;
+        if (gated && !(0, log_buffer_1.isLogBufferActive)())
+          return void 0;
+        const line = formatter(messages, { ...format, level: levelName, masks, maskLog });
+        if ((0, log_buffer_1.isLogBufferActive)() && typeof line === "string")
+          (0, log_buffer_1.appendToLogBuffer)(line);
+        return gated ? void 0 : line;
+      }
       function debug(...messages) {
-        if (level < log_level_1.LogLevel.debug)
-          return;
-        const options = { ...format, level: "debug", masks, maskLog };
-        handler.log(formatter(messages, options));
+        const line = emit(log_level_1.LogLevel.debug, "debug", messages);
+        if (line !== void 0)
+          handler.log(line);
       }
       function log(...messages) {
-        if (level < log_level_1.LogLevel.info)
-          return;
-        const options = { ...format, level: "info", masks, maskLog };
-        handler.log(formatter(messages, options));
+        const line = emit(log_level_1.LogLevel.info, "info", messages);
+        if (line !== void 0)
+          handler.log(line);
       }
       function warn(...messages) {
-        if (level < log_level_1.LogLevel.warn)
+        const line = emit(log_level_1.LogLevel.warn, "warn", messages);
+        if (line === void 0)
           return;
-        const options = { ...format, level: "warn", masks, maskLog };
         if (handler.warn)
-          handler.warn(formatter(messages, options));
+          handler.warn(line);
         else
-          handler.log(formatter(messages, options));
+          handler.log(line);
       }
       function error(...messages) {
-        if (level < log_level_1.LogLevel.error)
+        const line = emit(log_level_1.LogLevel.error, "error", messages);
+        if (line === void 0)
           return;
-        const options = { ...format, level: "error", masks, maskLog };
         if (handler.error)
-          handler.error(formatter(messages, options));
+          handler.error(line);
         else
-          handler.log(formatter(messages, options));
+          handler.log(line);
       }
       function fatal(...messages) {
-        if (level < log_level_1.LogLevel.fatal)
+        const line = emit(log_level_1.LogLevel.fatal, "fatal", messages);
+        if (line === void 0)
           return;
-        const options = { ...format, level: "fatal", masks, maskLog };
         if (handler.fatal)
-          handler.fatal(formatter(messages, options));
+          handler.fatal(line);
         else if (handler.error)
-          handler.error(formatter(messages, options));
+          handler.error(line);
         else
-          handler.log(formatter(messages, options));
+          handler.log(line);
       }
     }
     exports.makePrinter = makePrinter;
@@ -19830,6 +19907,7 @@ var require_browser6 = __commonJS({
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     __exportStar(require_formatter(), exports);
+    __exportStar(require_log_buffer(), exports);
     __exportStar(require_handler_console(), exports);
     __exportStar(require_handler_debug(), exports);
     __exportStar(require_logger(), exports);
@@ -74567,6 +74645,108 @@ var require_delete_test = __commonJS({
   }
 });
 
+// ../core-base/dist/server/sdk-log-upload.js
+var require_sdk_log_upload = __commonJS({
+  "../core-base/dist/server/sdk-log-upload.js"(exports) {
+    "use strict";
+    init_global();
+    init_process();
+    init_setImmediate();
+    init_buffer();
+    init_setInterval();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.makeSdkLogUpload = void 0;
+    var req_1 = (init_dist(), __toCommonJS(dist_exports));
+    function makeSdkLogUpload({ url, proxy, httpVersion }) {
+      let created = false;
+      let stopped = false;
+      let chain = Promise.resolve();
+      async function append(text) {
+        if (stopped || !text)
+          return;
+        try {
+          if (!created) {
+            const res2 = await (0, req_1.req)(url, {
+              method: "PUT",
+              headers: { "x-ms-blob-type": "AppendBlob", "Content-Length": "0" },
+              proxy,
+              httpVersion
+            });
+            if (!res2.ok && res2.status !== 409)
+              throw new Error(`create blob failed (${res2.status})`);
+            created = true;
+          }
+          const res = await (0, req_1.req)(withQuery(url, "comp=appendblock"), { method: "PUT", body: text, proxy, httpVersion });
+          if (!res.ok)
+            throw new Error(`appendblock failed (${res.status})`);
+        } catch {
+          stopped = true;
+        }
+      }
+      return (text) => chain = chain.then(() => append(text));
+    }
+    exports.makeSdkLogUpload = makeSdkLogUpload;
+    var withQuery = (url, q) => url + (url.includes("?") ? "&" : "?") + q;
+  }
+});
+
+// ../core-base/dist/sdk-log-streaming.js
+var require_sdk_log_streaming = __commonJS({
+  "../core-base/dist/sdk-log-streaming.js"(exports) {
+    "use strict";
+    init_global();
+    init_process();
+    init_setImmediate();
+    init_buffer();
+    init_setInterval();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.decideSdkLogStreaming = void 0;
+    var logger_1 = require_browser6();
+    var sdk_log_upload_1 = require_sdk_log_upload();
+    var SDK_LOG_RUN_ID = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    var SDK_LOG_PLACEHOLDER = "__sdk_logs_batch_id__";
+    var sdkLogDecided = false;
+    var sdkLogDrain;
+    function decideSdkLogStreaming(account) {
+      var _a, _b;
+      if (!sdkLogDecided) {
+        sdkLogDecided = true;
+        const disabled = !!process.env.APPLITOOLS_DISABLE_BACKEND_LOGS;
+        if (!account.collectSdkLogs || !account.sdkLogsUploadUrl || disabled) {
+          (0, logger_1.disableLogBuffer)();
+        } else {
+          const url = account.sdkLogsUploadUrl.split(SDK_LOG_PLACEHOLDER).join(encodeURIComponent(SDK_LOG_RUN_ID));
+          const upload = (0, sdk_log_upload_1.makeSdkLogUpload)({
+            url,
+            proxy: account.eyesServer.proxy,
+            httpVersion: account.eyesServer.httpVersion
+          });
+          sdkLogDrain = () => {
+            const text = (0, logger_1.consumeLogBuffer)();
+            if (text)
+              void upload(text);
+          };
+          (0, logger_1.onLogBufferFull)(sdkLogDrain);
+          const timer = setIntervalBrowser(() => sdkLogDrain === null || sdkLogDrain === void 0 ? void 0 : sdkLogDrain(), 5e3);
+          (_b = (_a = timer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+          installSdkLogShutdownHooks();
+        }
+      }
+    }
+    exports.decideSdkLogStreaming = decideSdkLogStreaming;
+    var shutdownHooksInstalled = false;
+    function installSdkLogShutdownHooks() {
+      if (shutdownHooksInstalled)
+        return;
+      shutdownHooksInstalled = true;
+      const shutdown = () => sdkLogDrain === null || sdkLogDrain === void 0 ? void 0 : sdkLogDrain();
+      process.on("beforeExit", shutdown);
+      process.on("SIGINT", shutdown);
+      process.on("SIGTERM", shutdown);
+    }
+  }
+});
+
 // ../core-base/dist/get-account-info.js
 var require_get_account_info = __commonJS({
   "../core-base/dist/get-account-info.js"(exports) {
@@ -74610,6 +74790,7 @@ var require_get_account_info = __commonJS({
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.makeGetAccountInfo = void 0;
+    var sdk_log_streaming_1 = require_sdk_log_streaming();
     var utils2 = __importStar(require_browser3());
     function makeGetAccountInfo({ requests, agentId: defaultAgentId, logger: mainLogger }) {
       return async function getAccountInfo({ settings, logger = mainLogger }) {
@@ -74618,11 +74799,13 @@ var require_get_account_info = __commonJS({
         settings.agentId = `${defaultAgentId} ${settings.agentId ? `[${settings.agentId}]` : ""}`.trim();
         logger.log('Command "getAccountInfo" is called with settings', settings);
         const account = await requests.getAccountInfo({ settings, logger });
-        return {
+        const result = {
           ...account,
           eyesServer: { ...account.eyesServer, agentId: settings.agentId },
           ufgServer: { ...account.ufgServer, agentId: settings.agentId }
         };
+        (0, sdk_log_streaming_1.decideSdkLogStreaming)(result);
+        return result;
       };
     }
     exports.makeGetAccountInfo = makeGetAccountInfo;
@@ -75048,6 +75231,7 @@ var require_dist2 = __commonJS({
     __exportStar(require_core(), exports);
     __exportStar(require_eyes(), exports);
     __exportStar(require_requests(), exports);
+    __exportStar(require_sdk_log_upload(), exports);
     __exportStar(require_core_error(), exports);
     __exportStar(require_missingApiKeyError(), exports);
     __exportStar(require_test_error(), exports);
@@ -82742,7 +82926,7 @@ ${l2}`}`, { bundledCss: u2, unfetchedResources: a2 };
                 return m3 && (k2.shadowRoot = m3), k2;
               }
             }(t3);
-            f2(l2.doCaptureDoc), d2(l2.waitForImages), await Promise.all(m2), f2(l2.waitForImages), T2.version = "1.4.0", T2.scriptVersion = "11.8.1";
+            f2(l2.doCaptureDoc), d2(l2.waitForImages), await Promise.all(m2), f2(l2.waitForImages), T2.version = "1.4.0", T2.scriptVersion = "11.8.3";
             const N2 = p2.length ? `${p2.join("\n")}
 ` : "", P2 = h2.size ? `${Array.from(h2).join("\n")}
 ` : "", A2 = JSON.stringify({ separator: w2, cssStartToken: y2, cssEndToken: y2, iframeStartToken: `"${g2}`, iframeEndToken: `${g2}"` });
@@ -89728,7 +89912,7 @@ var require_captureDomPollForIE = __commonJS({
                     case 24:
                       return L2 = e4.sent, A2(E2.prefetchCss), j2 = U0({ parseCss: D0, CSSImportRule, getCssFromCache: L2, absolutizeUrl: j0, unfetchedToken: _2 }), k2 = z0({ getCssFromCache: L2, absolutizeUrl: j0 }), C2 = V0({ extractCssFromNode: k2, getBundledCssFromCssText: j2, unfetchedToken: _2 }), S2(E2.doCaptureDoc), M2 = H2(i3), A2(E2.doCaptureDoc), S2(E2.waitForImages), e4.next = 35, Promise.all(O2);
                     case 35:
-                      return A2(E2.waitForImages), M2.version = "1.4.0", M2.scriptVersion = "11.8.1", N2 = T2.length ? T2.join("\n") + "\n" : "", U2 = x2.size ? Array.from(x2).join("\n") + "\n" : "", D2 = JSON.stringify({ separator: P2, cssStartToken: _2, cssEndToken: _2, iframeStartToken: '"' + R2, iframeEndToken: R2 + '"' }), A2(E2.total), B2 = JSON.stringify(M2), z2 = D2 + "\n" + U2 + P2 + "\n" + N2 + P2 + "\n" + ("string" == typeof B2 ? B2 : H0(M2)) + F2(), console.log("[captureFrame]", JSON.stringify(E2)), e4.abrupt("return", z2);
+                      return A2(E2.waitForImages), M2.version = "1.4.0", M2.scriptVersion = "11.8.3", N2 = T2.length ? T2.join("\n") + "\n" : "", U2 = x2.size ? Array.from(x2).join("\n") + "\n" : "", D2 = JSON.stringify({ separator: P2, cssStartToken: _2, cssEndToken: _2, iframeStartToken: '"' + R2, iframeEndToken: R2 + '"' }), A2(E2.total), B2 = JSON.stringify(M2), z2 = D2 + "\n" + U2 + P2 + "\n" + N2 + P2 + "\n" + ("string" == typeof B2 ? B2 : H0(M2)) + F2(), console.log("[captureFrame]", JSON.stringify(E2)), e4.abrupt("return", z2);
                     case 46:
                     case "end":
                       return e4.stop();
@@ -104734,7 +104918,7 @@ creating temp style for access.`), r2 = Qh(e3);
               function M2(e3) {
                 return r3.defaultView && r3.defaultView.frameElement && r3.defaultView.frameElement.getAttribute(e3);
               }
-            }(n3).then((e3) => (m2.log("processPage end"), e3.scriptVersion = "4.17.3", e3));
+            }(n3).then((e3) => (m2.log("processPage end"), e3.scriptVersion = "4.17.5", e3));
           }, n2[S], "domSnapshotResult");
           return function(e3) {
             try {
@@ -129503,6 +129687,292 @@ var require_get_eyes_results = __commonJS({
   }
 });
 
+// ../../node_modules/shell-quote/quote.js
+var require_quote = __commonJS({
+  "../../node_modules/shell-quote/quote.js"(exports, module) {
+    "use strict";
+    init_global();
+    init_process();
+    init_setImmediate();
+    init_buffer();
+    init_setInterval();
+    var OPS = [
+      "||",
+      "&&",
+      ";;",
+      "|&",
+      "<(",
+      "<<<",
+      ">>",
+      ">&",
+      "<&",
+      "&",
+      ";",
+      "(",
+      ")",
+      "|",
+      "<",
+      ">"
+    ];
+    var LINE_TERMINATORS = /[\n\r\u2028\u2029]/;
+    var GLOB_SHELL_SPECIAL = /[\s#!"$&'():;<=>@\\^`|]/g;
+    module.exports = function quote(xs) {
+      return xs.map(function(s) {
+        if (s === "") {
+          return "''";
+        }
+        if (s && typeof s === "object") {
+          if (s.op === "glob") {
+            if (typeof s.pattern !== "string") {
+              throw new TypeError("glob token requires a string `pattern`");
+            }
+            if (LINE_TERMINATORS.test(s.pattern)) {
+              throw new TypeError("glob `pattern` must not contain line terminators");
+            }
+            return s.pattern.replace(GLOB_SHELL_SPECIAL, "\\$&");
+          }
+          if (typeof s.op === "string") {
+            if (OPS.indexOf(s.op) < 0) {
+              throw new TypeError("invalid `op` value: " + JSON.stringify(s.op));
+            }
+            return s.op.replace(/[\s\S]/g, "\\$&");
+          }
+          if (typeof s.comment === "string") {
+            if (LINE_TERMINATORS.test(s.comment)) {
+              throw new TypeError("`comment` must not contain line terminators");
+            }
+            return "#" + s.comment;
+          }
+          throw new TypeError("unrecognized object token shape");
+        }
+        if (/["\s\\]/.test(s) && !/'/.test(s)) {
+          return "'" + s.replace(/(['])/g, "\\$1") + "'";
+        }
+        if (/["'\s]/.test(s)) {
+          return '"' + s.replace(/(["\\$`!])/g, "\\$1") + '"';
+        }
+        return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, "$1\\$2");
+      }).join(" ");
+    };
+  }
+});
+
+// ../../node_modules/shell-quote/parse.js
+var require_parse2 = __commonJS({
+  "../../node_modules/shell-quote/parse.js"(exports, module) {
+    "use strict";
+    init_global();
+    init_process();
+    init_setImmediate();
+    init_buffer();
+    init_setInterval();
+    var CONTROL = "(?:" + [
+      "\\|\\|",
+      "\\&\\&",
+      ";;",
+      "\\|\\&",
+      "\\<\\(",
+      "\\<\\<\\<",
+      ">>",
+      ">\\&",
+      "<\\&",
+      "[&;()|<>]"
+    ].join("|") + ")";
+    var controlRE = new RegExp("^" + CONTROL + "$");
+    var META = "|&;()<> \\t";
+    var SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
+    var DOUBLE_QUOTE = "'((\\\\'|[^'])*?)'";
+    var hash = /^#$/;
+    var SQ = "'";
+    var DQ = '"';
+    var DS = "$";
+    var TOKEN = "";
+    var mult = 4294967296;
+    for (i = 0; i < 4; i++) {
+      TOKEN += (mult * Math.random()).toString(16);
+    }
+    var i;
+    var startsWithToken = new RegExp("^" + TOKEN);
+    function matchAll(s, r) {
+      var origIndex = r.lastIndex;
+      var matches = [];
+      var matchObj;
+      while (matchObj = r.exec(s)) {
+        matches.push(matchObj);
+        if (r.lastIndex === matchObj.index) {
+          r.lastIndex += 1;
+        }
+      }
+      r.lastIndex = origIndex;
+      return matches;
+    }
+    function getVar(env, pre, key) {
+      var r = typeof env === "function" ? env(key) : env[key];
+      if (typeof r === "undefined" && key != "") {
+        r = "";
+      } else if (typeof r === "undefined") {
+        r = "$";
+      }
+      if (typeof r === "object") {
+        return pre + TOKEN + JSON.stringify(r) + TOKEN;
+      }
+      return pre + r;
+    }
+    function parseInternal(string, env, opts) {
+      if (!opts) {
+        opts = {};
+      }
+      var BS = opts.escape || "\\";
+      var BAREWORD = "(\\" + BS + `['"` + META + `]|[^\\s'"` + META + "])+";
+      var chunker = new RegExp([
+        "(" + CONTROL + ")",
+        // control chars
+        "(" + BAREWORD + "|" + SINGLE_QUOTE + "|" + DOUBLE_QUOTE + ")+"
+      ].join("|"), "g");
+      var matches = matchAll(string, chunker);
+      if (matches.length === 0) {
+        return [];
+      }
+      if (!env) {
+        env = {};
+      }
+      var commented = false;
+      return matches.map(function(match) {
+        var s = match[0];
+        if (!s || commented) {
+          return void 0;
+        }
+        if (controlRE.test(s)) {
+          return { op: s };
+        }
+        var quote = false;
+        var esc = false;
+        var out = "";
+        var isGlob = false;
+        var i2;
+        function parseEnvVar() {
+          i2 += 1;
+          var varend;
+          var varname;
+          var char = s.charAt(i2);
+          if (char === "{") {
+            i2 += 1;
+            if (s.charAt(i2) === "}") {
+              throw new Error("Bad substitution: " + s.slice(i2 - 2, i2 + 1));
+            }
+            varend = s.indexOf("}", i2);
+            if (varend < 0) {
+              throw new Error("Bad substitution: " + s.slice(i2));
+            }
+            varname = s.slice(i2, varend);
+            i2 = varend;
+          } else if (/[*@#?$!_-]/.test(char)) {
+            varname = char;
+            i2 += 1;
+          } else {
+            var slicedFromI = s.slice(i2);
+            varend = slicedFromI.match(/[^\w\d_]/);
+            if (!varend) {
+              varname = slicedFromI;
+              i2 = s.length;
+            } else {
+              varname = slicedFromI.slice(0, varend.index);
+              i2 += varend.index - 1;
+            }
+          }
+          return getVar(env, "", varname);
+        }
+        for (i2 = 0; i2 < s.length; i2++) {
+          var c = s.charAt(i2);
+          isGlob = isGlob || !quote && (c === "*" || c === "?");
+          if (esc) {
+            out += c;
+            esc = false;
+          } else if (quote) {
+            if (c === quote) {
+              quote = false;
+            } else if (quote == SQ) {
+              out += c;
+            } else {
+              if (c === BS) {
+                i2 += 1;
+                c = s.charAt(i2);
+                if (c === DQ || c === BS || c === DS) {
+                  out += c;
+                } else {
+                  out += BS + c;
+                }
+              } else if (c === DS) {
+                out += parseEnvVar();
+              } else {
+                out += c;
+              }
+            }
+          } else if (c === DQ || c === SQ) {
+            quote = c;
+          } else if (controlRE.test(c)) {
+            return { op: s };
+          } else if (hash.test(c)) {
+            commented = true;
+            var commentObj = { comment: string.slice(match.index + i2 + 1) };
+            if (out.length) {
+              return [out, commentObj];
+            }
+            return [commentObj];
+          } else if (c === BS) {
+            esc = true;
+          } else if (c === DS) {
+            out += parseEnvVar();
+          } else {
+            out += c;
+          }
+        }
+        if (isGlob) {
+          return { op: "glob", pattern: out };
+        }
+        return out;
+      }).reduce(function(prev, arg) {
+        return typeof arg === "undefined" ? prev : prev.concat(arg);
+      }, []);
+    }
+    module.exports = function parse(s, env, opts) {
+      var mapped = parseInternal(s, env, opts);
+      if (typeof env !== "function") {
+        return mapped;
+      }
+      return mapped.reduce(function(acc, s2) {
+        if (typeof s2 === "object") {
+          return acc.concat(s2);
+        }
+        var xs = s2.split(RegExp("(" + TOKEN + ".*?" + TOKEN + ")", "g"));
+        if (xs.length === 1) {
+          return acc.concat(xs[0]);
+        }
+        return acc.concat(xs.filter(Boolean).map(function(x) {
+          if (startsWithToken.test(x)) {
+            return JSON.parse(x.split(TOKEN)[1]);
+          }
+          return x;
+        }));
+      }, []);
+    };
+  }
+});
+
+// ../../node_modules/shell-quote/index.js
+var require_shell_quote = __commonJS({
+  "../../node_modules/shell-quote/index.js"(exports) {
+    "use strict";
+    init_global();
+    init_process();
+    init_setImmediate();
+    init_buffer();
+    init_setInterval();
+    exports.quote = require_quote();
+    exports.parse = require_parse2();
+  }
+});
+
 // ../core/dist/utils/extract-git-info.js
 var require_extract_git_info = __commonJS({
   "../core/dist/utils/extract-git-info.js"(exports) {
@@ -129548,10 +130018,11 @@ var require_extract_git_info = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.extractBranchLookupFallbackList = exports.isISODate = exports.extractBranchingTimestamp = exports.extractBuildIdFromCI = exports.extractCIBranchName = exports.extractGitRepo = exports.extractGitBranch = exports.extractLatestCommitInfo = exports.getPrimaryRemoteName = exports.cacheKey = void 0;
+    exports.extractBranchLookupFallbackList = exports.getBranchAncestryByLocalBranches = exports.getBranchAncestryByCommits = exports.isISODate = exports.extractBranchingTimestamp = exports.extractBuildIdFromCI = exports.extractCIBranchName = exports.extractGitRepo = exports.extractGitBranch = exports.extractLatestCommitInfo = exports.extractDefaultBranch = exports.checkGitEnvironment = exports.resolveBranchToLocalRef = exports.getPrimaryRemoteName = exports.cacheKey = void 0;
     var utils2 = __importStar(require_browser3());
     var fs_1 = __importDefault((init_fs(), __toCommonJS(fs_exports)));
     var path_1 = __importDefault(require_path_browserify());
+    var shell_quote_1 = require_shell_quote();
     var logger_1 = require_browser6();
     var isDebugMode = () => process.env.RUNNER_DEBUG === "1";
     exports.cacheKey = "default";
@@ -129571,14 +130042,229 @@ var require_extract_git_info = __commonJS({
         cwd: (_a = args[0].execOptions) === null || _a === void 0 ? void 0 : _a.cwd
       };
     });
-    exports.extractLatestCommitInfo = utils2.general.cachify(async function({ execOptions, logger = (0, logger_1.makeLogger)() }) {
-      let result;
+    async function resolveBranchToLocalRef({ branchName, remoteName, execOptions, logger = (0, logger_1.makeLogger)() }) {
+      const [local, tracking] = await Promise.all([
+        executeWithLog((0, shell_quote_1.quote)(["git", "rev-parse", "--verify", "--quiet", `refs/heads/${branchName}`]), {
+          execOptions,
+          logger
+        }),
+        executeWithLog((0, shell_quote_1.quote)(["git", "rev-parse", "--verify", "--quiet", `refs/remotes/${remoteName}/${branchName}`]), {
+          execOptions,
+          logger
+        })
+      ]);
+      if (local.code === 0 && local.stdout.trim()) {
+        return branchName;
+      }
+      if (tracking.code === 0 && tracking.stdout.trim()) {
+        const create = await executeWithLog((0, shell_quote_1.quote)(["git", "branch", branchName, `${remoteName}/${branchName}`]), {
+          execOptions,
+          logger
+        });
+        if (create.code === 0) {
+          logger.log(`resolveBranchToLocalRef: created local ref refs/heads/${branchName} from ${remoteName}/${branchName}`);
+          return branchName;
+        }
+        const recheck = await executeWithLog((0, shell_quote_1.quote)(["git", "rev-parse", "--verify", "--quiet", `refs/heads/${branchName}`]), {
+          execOptions,
+          logger
+        });
+        if (recheck.code === 0 && recheck.stdout.trim())
+          return branchName;
+      }
+      const env = await (0, exports.checkGitEnvironment)({ execOptions, logger });
+      if (env.remoteAccessible) {
+        const lsR = await executeWithLog((0, shell_quote_1.quote)(["git", "ls-remote", "--heads", remoteName, branchName]), {
+          execOptions,
+          logger
+        });
+        if (lsR.code === 0 && lsR.stdout.trim()) {
+          const fetched = await executeWithLog((0, shell_quote_1.quote)(["git", "fetch", remoteName, `${branchName}:${branchName}`, "--filter=tree:0"]), { execOptions, logger });
+          if (fetched.code === 0) {
+            logger.log(`resolveBranchToLocalRef: fetched ${branchName} from ${remoteName} into refs/heads/${branchName}`);
+            return branchName;
+          }
+        }
+      }
+      return void 0;
+    }
+    exports.resolveBranchToLocalRef = resolveBranchToLocalRef;
+    exports.checkGitEnvironment = utils2.general.cachify(async function({ execOptions, logger = (0, logger_1.makeLogger)() }) {
+      var _a, _b, _c, _d, _e, _f;
+      let gitInstalled = false;
+      let insideRepo = false;
+      let remoteAccessible = false;
+      let remoteName;
+      const reasons = [];
+      const finalize = (extraReason) => {
+        if (extraReason)
+          reasons.push(extraReason);
+        const result = {
+          gitInstalled,
+          insideRepo,
+          remoteAccessible,
+          ok: gitInstalled && insideRepo,
+          reason: reasons.length ? reasons.join("; ") : "ok",
+          remoteName
+        };
+        try {
+          logGitEnvironmentBanner(logger, result);
+        } catch {
+        }
+        return result;
+      };
       try {
-        const githubPullRequestLastCommitSha = await extractGithubPullRequestLastCommitSha();
-        result = await executeWithLog(`git log ${githubPullRequestLastCommitSha !== null && githubPullRequestLastCommitSha !== void 0 ? githubPullRequestLastCommitSha : ""} -1 --format="%aI %H"`, {
+        try {
+          const versionResult = await executeWithLog("git --version", { execOptions, logger });
+          if (versionResult.code !== 0) {
+            return finalize(`git binary: ${((_a = versionResult.stderr) === null || _a === void 0 ? void 0 : _a.trim()) || `exit ${versionResult.code} (command not found?)`}`);
+          }
+          gitInstalled = true;
+          const repoResult = await executeWithLog("git rev-parse --is-inside-work-tree", { execOptions, logger });
+          if (repoResult.code !== 0 || repoResult.stdout.trim() !== "true") {
+            return finalize(`repo: ${((_b = repoResult.stderr) === null || _b === void 0 ? void 0 : _b.trim()) || "not inside a git work tree"}`);
+          }
+          insideRepo = true;
+          const remotesResult = await executeWithLog("git remote", { execOptions, logger });
+          const remotesText = remotesResult.stdout.trim();
+          if (remotesResult.code !== 0 || !remotesText) {
+            return finalize(`remote: ${((_c = remotesResult.stderr) === null || _c === void 0 ? void 0 : _c.trim()) || "no remote configured"}`);
+          }
+          const remotes = remotesText.split(/\s+/).filter(Boolean);
+          remoteName = remotes.includes("origin") ? "origin" : remotes[0];
+          const probe = await executeWithLog((0, shell_quote_1.quote)(["git", "ls-remote", remoteName, "HEAD"]), { execOptions, logger });
+          if (probe.code !== 0) {
+            return finalize(`remote: ${((_d = probe.stderr) === null || _d === void 0 ? void 0 : _d.trim()) || `ls-remote exit ${probe.code}`}`);
+          }
+          remoteAccessible = true;
+          return finalize();
+        } catch (err) {
+          return finalize(`probe threw: ${(_e = err === null || err === void 0 ? void 0 : err.message) !== null && _e !== void 0 ? _e : err}`);
+        }
+      } catch (catastrophic) {
+        return {
+          gitInstalled: false,
+          insideRepo: false,
+          remoteAccessible: false,
+          ok: false,
+          reason: `checkGitEnvironment catastrophic failure: ${(_f = catastrophic === null || catastrophic === void 0 ? void 0 : catastrophic.message) !== null && _f !== void 0 ? _f : catastrophic}`,
+          remoteName: void 0
+        };
+      }
+    }, (args) => {
+      var _a, _b;
+      return { cwd: (_b = (_a = args[0]) === null || _a === void 0 ? void 0 : _a.execOptions) === null || _b === void 0 ? void 0 : _b.cwd };
+    });
+    function logGitEnvironmentBanner(logger, r) {
+      const sep = "============================================================";
+      const allGood = r.gitInstalled && r.insideRepo && r.remoteAccessible;
+      logger.log(sep);
+      if (allGood) {
+        logger.log("APPLITOOLS GIT ENVIRONMENT CHECK \u2713 all ok");
+      } else if (!r.gitInstalled) {
+        logger.log("APPLITOOLS GIT ENVIRONMENT CHECK \u2717 GIT NOT INSTALLED");
+      } else if (!r.insideRepo) {
+        logger.log("APPLITOOLS GIT ENVIRONMENT CHECK \u2717 NOT IN A GIT REPOSITORY");
+      } else if (!r.remoteAccessible) {
+        logger.log("APPLITOOLS GIT ENVIRONMENT CHECK \u2717 REMOTE NOT ACCESSIBLE");
+      }
+      logger.log(`  git binary:  ${r.gitInstalled ? "\u2713 installed" : "\u2717 NOT FOUND"}`);
+      if (r.gitInstalled) {
+        logger.log(`  repo:        ${r.insideRepo ? "\u2713 inside work tree" : "\u2717 NOT INSIDE A WORK TREE"}`);
+      }
+      if (r.gitInstalled && r.insideRepo) {
+        const remoteLine = r.remoteAccessible ? `\u2713 accessible (${r.remoteName})` : r.remoteName ? `\u2717 NOT ACCESSIBLE (${r.remoteName})` : "\u2717 NONE CONFIGURED";
+        logger.log(`  remote:      ${remoteLine}`);
+      }
+      if (!allGood) {
+        logger.log(`  reason:      ${r.reason}`);
+        if (!r.gitInstalled) {
+          logger.log("  \u2192 All git-based SCM features will be SKIPPED.");
+          logger.log("  \u2192 Install git or add it to PATH to enable branch detection and baseline inheritance.");
+        } else if (!r.insideRepo) {
+          logger.log("  \u2192 All git-based SCM features will be SKIPPED.");
+          logger.log("  \u2192 Run this from inside a git working tree to enable branch detection.");
+        } else if (!r.remoteAccessible) {
+          logger.log("  \u2192 All remote-dependent fallbacks will be SKIPPED.");
+          logger.log("  \u2192 Branch lookup may be incomplete. Verify network / credentials / remote config.");
+        }
+      }
+      logger.log(sep);
+    }
+    exports.extractDefaultBranch = utils2.general.cachify(async function({ execOptions, logger = (0, logger_1.makeLogger)() }) {
+      var _a;
+      logger = logger.extend({ tags: [`extract-default-branch-${utils2.general.shortid()}`] });
+      const envOverride = (_a = process.env.APPLITOOLS_DEFAULT_BRANCH) === null || _a === void 0 ? void 0 : _a.trim();
+      if (envOverride) {
+        logger.log(`extractDefaultBranch: using APPLITOOLS_DEFAULT_BRANCH="${envOverride}"`);
+        return envOverride;
+      }
+      const env = await (0, exports.checkGitEnvironment)({ execOptions, logger });
+      if (!env.ok) {
+        logger.log("extractDefaultBranch: git environment not ok, falling back to 'main'");
+        return "main";
+      }
+      const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
+      try {
+        const r = await executeWithLog((0, shell_quote_1.quote)(["git", "symbolic-ref", "--short", `refs/remotes/${remoteName}/HEAD`]), {
           execOptions,
           logger
         });
+        if (!r.stderr && r.stdout.trim()) {
+          const out = r.stdout.trim();
+          const normalized = out.replace(new RegExp(`^${remoteName}/`), "");
+          if (normalized) {
+            logger.log(`extractDefaultBranch: resolved via symbolic-ref -> "${normalized}"`);
+            return normalized;
+          }
+        }
+      } catch (err) {
+        if (isDebugMode())
+          logger.log("extractDefaultBranch: symbolic-ref step failed, continuing", err);
+      }
+      try {
+        const r = await executeWithLog((0, shell_quote_1.quote)(["git", "ls-remote", "--symref", remoteName, "HEAD"]), { execOptions, logger });
+        if (!r.stderr && r.stdout) {
+          const match = r.stdout.match(/^ref:\s+refs\/heads\/([^\s]+)\s+HEAD/m);
+          if (match && match[1]) {
+            logger.log(`extractDefaultBranch: resolved via ls-remote --symref -> "${match[1]}"`);
+            return match[1];
+          }
+        }
+      } catch (err) {
+        if (isDebugMode())
+          logger.log("extractDefaultBranch: ls-remote --symref step failed, continuing", err);
+      }
+      try {
+        const r = await executeWithLog("git config --get init.defaultBranch", { execOptions, logger });
+        if (!r.stderr && r.stdout.trim()) {
+          logger.log(`extractDefaultBranch: resolved via init.defaultBranch -> "${r.stdout.trim()}"`);
+          return r.stdout.trim();
+        }
+      } catch (err) {
+        if (isDebugMode())
+          logger.log("extractDefaultBranch: init.defaultBranch step failed, continuing", err);
+      }
+      logger.log('extractDefaultBranch: falling back to literal "main"');
+      return "main";
+    }, (args) => {
+      var _a, _b;
+      return { cwd: (_b = (_a = args[0]) === null || _a === void 0 ? void 0 : _a.execOptions) === null || _b === void 0 ? void 0 : _b.cwd };
+    });
+    exports.extractLatestCommitInfo = utils2.general.cachify(async function({ execOptions, logger = (0, logger_1.makeLogger)() }) {
+      const env = await (0, exports.checkGitEnvironment)({ execOptions, logger });
+      if (!env.ok) {
+        logger.log("extractLatestCommitInfo: git environment not ok, skipping");
+        return void 0;
+      }
+      let result;
+      try {
+        const githubPullRequestLastCommitSha = await extractGithubPullRequestLastCommitSha();
+        const logArgs = ["git", "log"];
+        if (githubPullRequestLastCommitSha)
+          logArgs.push(githubPullRequestLastCommitSha);
+        logArgs.push("-1", "--format=%aI %H");
+        result = await executeWithLog((0, shell_quote_1.quote)(logArgs), { execOptions, logger });
         if (result.stderr) {
           logger.log(`Error during extracting commit information from git`, result.stderr);
         } else {
@@ -129596,7 +130282,7 @@ var require_extract_git_info = __commonJS({
         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) {
           const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
-          await executeWithLog(`git fetch ${remoteName} --depth=2`, { execOptions, logger });
+          await executeWithLog((0, shell_quote_1.quote)(["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;
         }
@@ -129608,6 +130294,11 @@ var require_extract_git_info = __commonJS({
         logger.log(`Extracted branch name from CI environment: "${ciBranch}"`);
         return ciBranch;
       }
+      const env = await (0, exports.checkGitEnvironment)({ execOptions, logger });
+      if (!env.ok) {
+        logger.log("extractGitBranch: git environment not ok, no branch name available");
+        return void 0;
+      }
       const result = await executeWithLog("git branch --show-current", { execOptions, logger });
       if (result.stderr) {
         logger.log(`Error during extracting current branch from git`, result.stderr);
@@ -129624,10 +130315,15 @@ var require_extract_git_info = __commonJS({
       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 = utils2.general.cachify(async function({ execOptions, logger = (0, logger_1.makeLogger)() }) {
+      const env = await (0, exports.checkGitEnvironment)({ execOptions, logger });
+      if (!env.ok) {
+        logger.log("extractGitRepo: git environment not ok, returning empty repo info");
+        return {};
+      }
       const remotes = await extractRemotes();
       logger.log(`Extracted remotes from git: ${remotes}`);
       const remote = remotes.includes("origin") ? "origin" : remotes[0];
-      const result = await executeWithLog(`git remote get-url ${remote}`, { execOptions, logger });
+      const result = await executeWithLog((0, shell_quote_1.quote)(["git", "remote", "get-url", remote]), { execOptions, logger });
       if (result.stderr) {
         logger.log(`Error during extracting remote url from git`, result.stderr);
         return {};
@@ -129671,51 +130367,82 @@ var require_extract_git_info = __commonJS({
     }
     exports.extractBuildIdFromCI = extractBuildIdFromCI;
     exports.extractBranchingTimestamp = utils2.general.cachify(async function({ branchName, parentBranchName, execOptions, logger = (0, logger_1.makeLogger)() }) {
-      var _a;
       logger = logger.extend({ tags: [`extract-branching-timestamp-${utils2.general.shortid()}`] });
-      const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
-      const shallowCheckResult = await executeWithLog("git rev-parse --is-shallow-repository", {
-        execOptions,
-        logger
-      });
-      const isShallow = shallowCheckResult.stdout.trim() === "true";
-      if (isShallow) {
-        logger.log("extractBranchingTimestamp - Repository is a shallow clone, attempting to unshallow");
-        await executeFetchStrategy(isShallow, execOptions, logger);
-      }
-      const command = `HASH=$(git merge-base ${branchName} ${parentBranchName}) && git show -q --format=%aI $HASH`;
-      let result = await executeWithLog(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
-              });
-            }
+      try {
+        const env = await (0, exports.checkGitEnvironment)({ execOptions, logger });
+        if (!env.ok) {
+          logger.log("extractBranchingTimestamp: git environment not ok, skipping");
+          return void 0;
+        }
+        const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
+        const shallowCheckResult = await executeWithLog("git rev-parse --is-shallow-repository", {
+          execOptions,
+          logger
+        });
+        const isShallow = shallowCheckResult.stdout.trim() === "true";
+        if (isShallow) {
+          logger.log("extractBranchingTimestamp - Repository is a shallow clone, attempting to unshallow");
+          await executeFetchStrategy(isShallow, execOptions, logger);
+        }
+        async function getMergeBase(ref1, ref2) {
+          const { stdout, stderr } = await executeWithLog((0, shell_quote_1.quote)(["git", "merge-base", ref1, ref2]), { execOptions, logger });
+          if (stderr) {
+            if (isDebugMode())
+              logger.log(`getMergeBase failed for ${ref1} and ${ref2}: ${stderr}`);
+            return null;
           }
+          return stdout.trim();
         }
-      }
-      const timestamp = result.stdout.replace(/\s/g, "");
-      if (isISODate(timestamp)) {
-        logger.log("git branching timestamp successfully extracted", timestamp);
-        return timestamp;
-      } else {
-        logger.log(`Error during extracting merge timestamp: git branching timestamp is an invalid ISO date string: ${timestamp}. stderr: ${result.stderr}, stdout: ${result.stdout}`);
+        async function getTimestampForHash(hash) {
+          if (!hash)
+            return void 0;
+          const { stdout, stderr } = await executeWithLog((0, shell_quote_1.quote)(["git", "show", "-s", "--format=%aI", hash]), {
+            execOptions,
+            logger
+          });
+          const timestamp2 = stdout.trim();
+          if (stderr || !isISODate(timestamp2)) {
+            logger.log(`Error extracting timestamp for hash ${hash}: stderr: ${stderr}, stdout: ${stdout}`);
+            return void 0;
+          }
+          return timestamp2;
+        }
+        let mergeBaseHash = null;
+        mergeBaseHash = await getMergeBase(`${remoteName}/${branchName}`, `${remoteName}/${parentBranchName}`);
+        if (!mergeBaseHash) {
+          mergeBaseHash = await getMergeBase(branchName, parentBranchName);
+        }
+        if (!mergeBaseHash) {
+          const remoteBranches = await getAllRemoteBranches({ execOptions, logger });
+          if (!remoteBranches.has(parentBranchName)) {
+            logger.log(`Parent branch ${parentBranchName} not found on remote, cannot determine branching point.`);
+            return void 0;
+          }
+          const branchesToFetch = [parentBranchName];
+          if (branchName !== parentBranchName && remoteBranches.has(branchName)) {
+            branchesToFetch.push(branchName);
+          }
+          logger.log(`Fetching missing branches [${branchesToFetch.join(", ")}] from remote and retrying merge-base`);
+          for (const branch of branchesToFetch) {
+            await executeWithLog((0, shell_quote_1.quote)(["git", "fetch", remoteName, `${branch}:${branch}`, "--filter=tree:0"]), {
+              execOptions,
+              logger
+            });
+          }
+          mergeBaseHash = await getMergeBase(branchName, parentBranchName);
+        }
+        if (!mergeBaseHash) {
+          logger.log(`Could not find a merge-base for ${branchName} and ${parentBranchName}.`);
+          return void 0;
+        }
+        const timestamp = await getTimestampForHash(mergeBaseHash);
+        if (timestamp) {
+          logger.log(`git branching timestamp for parent '${parentBranchName}' successfully extracted: ${timestamp}`);
+          return timestamp;
+        }
+      } catch (err) {
+        logger.log("extractBranchingTimestamp: unexpected error, returning undefined", err);
+        return void 0;
       }
     }, (args) => {
       var _a;
@@ -129740,6 +130467,47 @@ 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 = isISODate;
+    var GIT_PREDICATE_MAX_ATTEMPTS = 3;
+    function classifyGitPredicate(result) {
+      const code = result.code;
+      const hasStderr = Boolean(result.stderr && result.stderr.trim());
+      if (code === 0 && !hasStderr)
+        return true;
+      if (code === 1 && !hasStderr)
+        return false;
+      return "error";
+    }
+    async function runGitPredicateWithRetry(command, { execOptions, logger }) {
+      let outcome = "error";
+      for (let attempt = 0; attempt < GIT_PREDICATE_MAX_ATTEMPTS; attempt++) {
+        const result = await executeWithLog(command, { execOptions, logger });
+        outcome = classifyGitPredicate(result);
+        if (outcome !== "error")
+          return outcome;
+        if (attempt < GIT_PREDICATE_MAX_ATTEMPTS - 1) {
+          await gitRetryBackoff(attempt, command, logger);
+        }
+      }
+      return outcome;
+    }
+    async function gitRetryBackoff(attempt, command, logger) {
+      const backoff = 50 * 2 ** attempt + Math.floor(Math.random() * 10);
+      if (isDebugMode()) {
+        logger.log(`git transient error (attempt ${attempt + 1}), retrying in ${backoff}ms: ${command}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, backoff));
+    }
+    async function runGitContainsWithRetry(command, { execOptions, logger }) {
+      for (let attempt = 0; attempt < GIT_PREDICATE_MAX_ATTEMPTS; attempt++) {
+        const result = await executeWithLog(command, { execOptions, logger });
+        if (!(result.stderr && result.stderr.trim()))
+          return result.stdout;
+        if (attempt < GIT_PREDICATE_MAX_ATTEMPTS - 1) {
+          await gitRetryBackoff(attempt, command, logger);
+        }
+      }
+      return "";
+    }
     async function parallelWithLimit(items, concurrency, fn) {
       const results = [];
       for (let i = 0; i < items.length; i += concurrency) {
@@ -129749,6 +130517,262 @@ var require_extract_git_info = __commonJS({
       }
       return results;
     }
+    async function getBranchAncestryByCommits({ gitBranchName, defaultBranch, execOptions, logger = (0, logger_1.makeLogger)() }) {
+      logger = logger.extend({ tags: [`get-branch-ancestry-by-commits-${utils2.general.shortid()}`] });
+      if (isDebugMode()) {
+        logger.log(`[byCommits] Start: gitBranchName=${gitBranchName}, defaultBranch=${defaultBranch}`);
+      }
+      const env = await (0, exports.checkGitEnvironment)({ execOptions, logger });
+      if (!env.ok) {
+        logger.log("[byCommits] git environment not ok, returning []");
+        return [];
+      }
+      try {
+        let mergeBaseResult = await executeWithLog((0, shell_quote_1.quote)(["git", "merge-base", gitBranchName, defaultBranch]), {
+          execOptions,
+          logger
+        });
+        if (mergeBaseResult.stderr || !mergeBaseResult.stdout.trim()) {
+          const remoteName2 = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
+          const resolved = await resolveBranchToLocalRef({ branchName: defaultBranch, remoteName: remoteName2, execOptions, logger });
+          if (resolved) {
+            mergeBaseResult = await executeWithLog((0, shell_quote_1.quote)(["git", "merge-base", gitBranchName, defaultBranch]), {
+              execOptions,
+              logger
+            });
+          }
+          if (mergeBaseResult.stderr || !mergeBaseResult.stdout.trim()) {
+            logger.log(`[byCommits] \u2717 merge-base ${gitBranchName} ${defaultBranch} failed (stderr="${mergeBaseResult.stderr}"), returning []`);
+            return [];
+          }
+        }
+        const mergeBase = mergeBaseResult.stdout.trim();
+        if (isDebugMode())
+          logger.log(`[byCommits] Merge-base resolved: ${mergeBase}`);
+        const logResult = await executeWithLog((0, shell_quote_1.quote)(["git", "log", "--format=%H", `${mergeBase}..${gitBranchName}`]), {
+          execOptions,
+          logger
+        });
+        if (logResult.stderr) {
+          logger.log(`[byCommits] \u2717 git log ${mergeBase}..${gitBranchName} failed (stderr="${logResult.stderr}"), returning []`);
+          return [];
+        }
+        const commits = logResult.stdout.trim().split("\n").filter(Boolean);
+        if (isDebugMode())
+          logger.log(`[byCommits] Walking ${commits.length} commit(s) in window ${mergeBase}..${gitBranchName}`);
+        const candidates = /* @__PURE__ */ new Set([defaultBranch, gitBranchName]);
+        const containResults = await parallelWithLimit(commits, 10, async (hash) => {
+          const r = await runGitContainsWithRetry((0, shell_quote_1.quote)(["git", "branch", "-a", "--contains", hash, "--format=%(refname:short)"]), { execOptions, logger });
+          return r.split("\n").map((line) => line.trim()).filter((b) => b && b !== "HEAD");
+        });
+        if (isDebugMode()) {
+          logger.log(`[byCommits] Branches containing commits in ${mergeBase}..${gitBranchName}:`, containResults);
+        }
+        for (const list of containResults)
+          for (const b of list)
+            candidates.add(b);
+        const atMergeBase = await runGitContainsWithRetry((0, shell_quote_1.quote)(["git", "branch", "-a", "--contains", mergeBase, "--format=%(refname:short)"]), { execOptions, logger });
+        for (const b of atMergeBase.split("\n").map((l) => l.trim()).filter((b2) => b2 && b2 !== "HEAD")) {
+          candidates.add(b);
+        }
+        if (isDebugMode()) {
+          logger.log(`[byCommits] Unioned candidates before descendant filter (${candidates.size}): ${Array.from(candidates).join(", ")}`);
+        }
+        const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
+        let droppedSelf = 0;
+        let droppedDescendants = 0;
+        let droppedCousins = 0;
+        const finalCandidates = await parallelWithLimit(Array.from(candidates), 10, async (branch) => {
+          const normalizedBranch = branch.replace(new RegExp(`^${remoteName}/`), "");
+          if (normalizedBranch === gitBranchName) {
+            droppedSelf++;
+            return null;
+          }
+          if (normalizedBranch === defaultBranch) {
+            if (isDebugMode())
+              logger.log(`[byCommits] KEEP base (default branch): ${normalizedBranch}`);
+            return normalizedBranch;
+          }
+          const isDescendant = await runGitPredicateWithRetry((0, shell_quote_1.quote)(["git", "merge-base", "--is-ancestor", gitBranchName, branch]), { execOptions, logger });
+          if (isDescendant === true) {
+            droppedDescendants++;
+            if (isDebugMode())
+              logger.log(`[byCommits] DROP descendant: ${normalizedBranch}`);
+            return null;
+          }
+          const mbAllResult = await runGitContainsWithRetry((0, shell_quote_1.quote)(["git", "merge-base", "--all", gitBranchName, branch]), {
+            execOptions,
+            logger
+          });
+          const mbCs = mbAllResult.split("\n").map((line) => line.trim()).filter(Boolean);
+          if (mbCs.length === 0) {
+            if (isDebugMode())
+              logger.log(`[byCommits] KEEP (no merge-base resolved, conservative): ${normalizedBranch}`);
+            return normalizedBranch;
+          }
+          let anyStrictlyAboveFloor = false;
+          for (const mbC of mbCs) {
+            if (mbC === mergeBase)
+              continue;
+            const floorIsAncestorOfMbC = await runGitPredicateWithRetry((0, shell_quote_1.quote)(["git", "merge-base", "--is-ancestor", mergeBase, mbC]), { execOptions, logger });
+            if (floorIsAncestorOfMbC === true || floorIsAncestorOfMbC === "error") {
+              anyStrictlyAboveFloor = true;
+              break;
+            }
+          }
+          if (!anyStrictlyAboveFloor) {
+            droppedCousins++;
+            if (isDebugMode())
+              logger.log(`[byCommits] DROP cousin (shares only the floor): ${normalizedBranch}`);
+            return null;
+          }
+          if (isDebugMode())
+            logger.log(`[byCommits] KEEP lineage point: ${normalizedBranch}`);
+          return normalizedBranch;
+        });
+        const finalCleanBranches = finalCandidates.filter((b) => b !== null);
+        const result = Array.from(new Set(finalCleanBranches)).sort();
+        if (isDebugMode()) {
+          logger.log(`[byCommits] Done. dropped(self=${droppedSelf}, descendants=${droppedDescendants}, cousins=${droppedCousins}) \u2192 ${result.length} lineage point(s): ${result.join(", ")}`);
+        }
+        return result;
+      } catch (err) {
+        logger.log("[byCommits] \u2717 ERROR", err);
+        return [];
+      }
+    }
+    exports.getBranchAncestryByCommits = getBranchAncestryByCommits;
+    async function getBranchAncestryByLocalBranches({ gitBranchName, defaultBranch, execOptions, logger = (0, logger_1.makeLogger)() }) {
+      logger = logger.extend({ tags: [`get-branch-ancestry-by-local-branches-${utils2.general.shortid()}`] });
+      if (isDebugMode()) {
+        logger.log(`[byLocalBranches] Start: gitBranchName=${gitBranchName}, defaultBranch=${defaultBranch}`);
+      }
+      const env = await (0, exports.checkGitEnvironment)({ execOptions, logger });
+      if (!env.ok) {
+        logger.log("[byLocalBranches] git environment not ok, returning []");
+        return [];
+      }
+      let droppedNoMb = 0;
+      let droppedRule1 = 0;
+      let droppedRule2 = 0;
+      let pinned = 0;
+      try {
+        let mergeBaseResult = await executeWithLog((0, shell_quote_1.quote)(["git", "merge-base", gitBranchName, defaultBranch]), {
+          execOptions,
+          logger
+        });
+        if (mergeBaseResult.stderr || !mergeBaseResult.stdout.trim()) {
+          const remoteName2 = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
+          const resolved = await resolveBranchToLocalRef({ branchName: defaultBranch, remoteName: remoteName2, execOptions, logger });
+          if (resolved) {
+            mergeBaseResult = await executeWithLog((0, shell_quote_1.quote)(["git", "merge-base", gitBranchName, defaultBranch]), {
+              execOptions,
+              logger
+            });
+          }
+          if (mergeBaseResult.stderr || !mergeBaseResult.stdout.trim()) {
+            logger.log(`[byLocalBranches] \u2717 merge-base ${gitBranchName} ${defaultBranch} failed (stderr="${mergeBaseResult.stderr}"), returning []`);
+            return [];
+          }
+        }
+        const mergeBase = mergeBaseResult.stdout.trim();
+        if (isDebugMode())
+          logger.log(`[byLocalBranches] Primary merge-base: ${mergeBase}`);
+        const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
+        const refsResult = await executeWithLog((0, shell_quote_1.quote)(["git", "for-each-ref", "--format=%(refname:short)", "refs/heads/", `refs/remotes/${remoteName}/`]), { execOptions, logger });
+        if (refsResult.stderr) {
+          logger.log(`[byLocalBranches] \u2717 for-each-ref failed (stderr="${refsResult.stderr}"), returning []`);
+          return [];
+        }
+        const candidateBranches = /* @__PURE__ */ new Map();
+        candidateBranches.set(defaultBranch, defaultBranch);
+        candidateBranches.set(gitBranchName, gitBranchName);
+        for (const raw of refsResult.stdout.split("\n")) {
+          const trimmed = raw.trim();
+          if (!trimmed)
+            continue;
+          const normalized = trimmed.replace(new RegExp(`^${remoteName}/`), "");
+          if (!normalized || normalized === "HEAD")
+            continue;
+          if (!candidateBranches.has(normalized)) {
+            candidateBranches.set(normalized, trimmed);
+          }
+        }
+        if (isDebugMode()) {
+          logger.log(`[byLocalBranches] Enumerated ${candidateBranches.size} candidate(s): ${Array.from(candidateBranches.keys()).join(", ")}`);
+        }
+        const results = await parallelWithLimit(Array.from(candidateBranches.entries()), 10, async ([branch, refToUse]) => {
+          if (branch === defaultBranch || branch === gitBranchName) {
+            pinned++;
+            if (isDebugMode())
+              logger.log(`[byLocalBranches] KEEP pinned:     ${branch}`);
+            return branch;
+          }
+          const branchMbR = await runGitContainsWithRetry((0, shell_quote_1.quote)(["git", "merge-base", "--all", refToUse, gitBranchName]), {
+            execOptions,
+            logger
+          });
+          const branchMbs = branchMbR.split("\n").map((line) => line.trim()).filter(Boolean);
+          if (branchMbs.length === 0) {
+            droppedNoMb++;
+            if (isDebugMode()) {
+              logger.log(`[byLocalBranches] DROP no-merge-base: ${branch}`);
+            }
+            return null;
+          }
+          let anyStrictlyAboveFloor = false;
+          for (const branchMb2 of branchMbs) {
+            if (branchMb2 === mergeBase)
+              continue;
+            const r1 = await runGitPredicateWithRetry((0, shell_quote_1.quote)(["git", "merge-base", "--is-ancestor", mergeBase, branchMb2]), {
+              execOptions,
+              logger
+            });
+            if (r1 === true || r1 === "error") {
+              anyStrictlyAboveFloor = true;
+              break;
+            }
+          }
+          if (!anyStrictlyAboveFloor) {
+            droppedRule1++;
+            if (isDebugMode()) {
+              logger.log(`[byLocalBranches] DROP Rule 1 (cousin \u2014 shares only the floor ${mergeBase}): ${branch} \u2014 bases=${branchMbs.join(",")}`);
+            }
+            return null;
+          }
+          const branchMb = branchMbs[0];
+          const r2 = await runGitPredicateWithRetry((0, shell_quote_1.quote)(["git", "merge-base", "--is-ancestor", gitBranchName, refToUse]), {
+            execOptions,
+            logger
+          });
+          if (r2 === true) {
+            droppedRule2++;
+            if (isDebugMode()) {
+              logger.log(`[byLocalBranches] DROP Rule 2 (descendant): ${branch} \u2014 ${gitBranchName} is its ancestor`);
+            }
+            return null;
+          }
+          if (r2 === "error") {
+            droppedRule2++;
+            if (isDebugMode())
+              logger.log(`[byLocalBranches] DROP Rule 2 (transient error): ${branch}`);
+            return null;
+          }
+          if (isDebugMode())
+            logger.log(`[byLocalBranches] KEEP ancestor:   ${branch} (mb=${branchMb})`);
+          return branch;
+        });
+        const result = Array.from(new Set(results.filter((b) => b !== null))).sort();
+        if (isDebugMode()) {
+          logger.log(`[byLocalBranches] Done. pinned=${pinned}, dropped(no-mb=${droppedNoMb}, rule1=${droppedRule1}, rule2=${droppedRule2}) \u2192 ${result.length} ancestor(s): ${result.join(", ")}`);
+        }
+        return result;
+      } catch (err) {
+        logger.log("[byLocalBranches] \u2717 ERROR", err);
+        return [];
+      }
+    }
+    exports.getBranchAncestryByLocalBranches = getBranchAncestryByLocalBranches;
     var getAllRemoteBranches = utils2.general.cachify(
       async function({ execOptions, logger }) {
         var _a;
@@ -129756,10 +130780,15 @@ var require_extract_git_info = __commonJS({
           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");
         }
+        const env = await (0, exports.checkGitEnvironment)({ execOptions, logger });
+        if (!env.remoteAccessible) {
+          logger.log("[getAllRemoteBranches] Skipping ls-remote (remote not accessible), returning empty set");
+          return /* @__PURE__ */ new Set();
+        }
         try {
           const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
           const startTime = Date.now();
-          const result = await executeWithLog(`git ls-remote --heads ${remoteName}`, {
+          const result = await executeWithLog((0, shell_quote_1.quote)(["git", "ls-remote", "--heads", remoteName]), {
             execOptions,
             logger
           });
@@ -129808,7 +130837,7 @@ var require_extract_git_info = __commonJS({
           return /* @__PURE__ */ new Set();
         }
       },
-      // Custom cache key generator - only cache by cwd, not by logger instance
+      // Cache by cwd only, not by logger instance.
       (args) => {
         var _a;
         return { cwd: (_a = args[0].execOptions) === null || _a === void 0 ? void 0 : _a.cwd };
@@ -129816,17 +130845,22 @@ var require_extract_git_info = __commonJS({
       5 * 60 * 1e3
     );
     async function executeFetchStrategy(isShallow, execOptions, logger) {
+      const env = await (0, exports.checkGitEnvironment)({ execOptions, logger });
+      if (!env.remoteAccessible) {
+        logger.log("executeFetchStrategy: skipping fetch (remote not accessible)");
+        return;
+      }
       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=blob:none`, {
+        await executeWithLog((0, shell_quote_1.quote)(["git", "fetch", remoteName, "--unshallow", "--filter=blob:none"]), {
           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`, {
+        await executeWithLog((0, shell_quote_1.quote)(["git", "fetch", remoteName, "--filter=tree:0"]), {
           execOptions,
           logger
         });
@@ -129834,9 +130868,14 @@ var require_extract_git_info = __commonJS({
       }
     }
     async function ensureRemoteBranchesAvailable(branchName, isShallow, execOptions, logger) {
+      const env = await (0, exports.checkGitEnvironment)({ execOptions, logger });
+      if (!env.remoteAccessible) {
+        logger.log("ensureRemoteBranchesAvailable: skipping (remote not accessible)");
+        return;
+      }
       try {
         const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
-        const symbolicResult = await executeWithLog(`git rev-parse --abbrev-ref ${branchName}@{upstream} `, {
+        const symbolicResult = await executeWithLog((0, shell_quote_1.quote)(["git", "rev-parse", "--abbrev-ref", `${branchName}@{upstream}`]), {
           execOptions,
           logger
         });
@@ -129845,12 +130884,14 @@ var require_extract_git_info = __commonJS({
           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 executeWithLog((0, shell_quote_1.quote)(["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`);
+        try {
+          await executeWithLog((0, shell_quote_1.quote)(["git", "remote", "set-head", remoteName, "-a"]), { execOptions, logger });
+        } catch (err) {
+          logger.log("ensureRemoteBranchesAvailable: remote set-head -a failed (continuing)", err);
+        }
       } catch (err) {
         logger.log("Note: Could not determine if branch is remote, continuing with topology discovery", err);
       }
@@ -129858,46 +130899,60 @@ var require_extract_git_info = __commonJS({
     exports.extractBranchLookupFallbackList = utils2.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-${utils2.general.shortid()}`] });
-      logger.log(`[PERF] extractBranchLookupFallbackList started for branch: ${gitBranchName}`);
+      if (isDebugMode())
+        logger.log(`[PERF] extractBranchLookupFallbackList started for branch: ${gitBranchName}`);
+      const env = await (0, exports.checkGitEnvironment)({ execOptions, logger });
+      if (!env.ok) {
+        logger.log("extractBranchLookupFallbackList: git environment not ok, skipping");
+        return void 0;
+      }
       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`);
+        if (isDebugMode())
+          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");
+          logger.log("Shallow clone detected and enableShallowClone=false, 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}...`);
+        if (isDebugMode())
+          logger.log(`[PERF] ensureRemoteBranchesAvailable took ${Date.now() - ensureRemoteStartTime}ms`);
         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);
-            }
-          }
+        const defaultBranch = await (0, exports.extractDefaultBranch)({ execOptions, logger });
+        logger.log(`Default branch detected: ${defaultBranch}`);
+        const resolvedDefaultBranch = await resolveBranchToLocalRef({
+          branchName: defaultBranch,
+          remoteName,
+          execOptions,
+          logger
+        });
+        if (!resolvedDefaultBranch) {
+          logger.log(`extractBranchLookupFallbackList: default branch "${defaultBranch}" not resolvable locally or on remote, skipping ancestry`);
+          return void 0;
+        }
+        const ancestryStrategy = (process.env.APPLITOOLS_BRANCH_ANCESTRY_STRATEGY || "commits").trim().toLowerCase();
+        const ancestryDriver = ancestryStrategy === "local" ? getBranchAncestryByLocalBranches : getBranchAncestryByCommits;
+        const ancestryStartTime = Date.now();
+        logger.log(`Discovering ancestor branches via "${ancestryStrategy}" strategy for ${gitBranchName} (default=${defaultBranch})...`);
+        const ancestry = await ancestryDriver({ gitBranchName, defaultBranch, execOptions, logger });
+        if (isDebugMode())
+          logger.log(`[PERF] Ancestry discovery took ${Date.now() - ancestryStartTime}ms`);
+        if (isDebugMode()) {
+          logger.log(`Ancestry discovery found ${ancestry.length} candidate branches: ${ancestry.join(", ")}`);
+        } else {
+          logger.log(`Ancestry discovery found ${ancestry.length} candidate branches`);
         }
-        let allBranches = Array.from(foundBranches);
-        logger.log(`[PERF] Topology discovery took ${Date.now() - topologyStartTime}ms`);
+        let allBranches = ancestry.filter((b) => b !== gitBranchName);
         if (isDebugMode()) {
-          logger.log(`Topology discovered ${allBranches.length} potential ancestor branches: ${allBranches.join(", ")}`);
+          logger.log(`Ancestry discovered ${allBranches.length} potential ancestor branches: ${allBranches.join(", ")}`);
         } else {
-          logger.log(`Topology discovered ${allBranches.length} potential ancestor branches`);
+          logger.log(`Ancestry discovered ${allBranches.length} potential ancestor branches`);
         }
         const remoteBranchesStartTime = Date.now();
         if (isDebugMode()) {
@@ -129947,48 +131002,41 @@ var require_extract_git_info = __commonJS({
             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] [PERF] Remote branch filtering took ${Date.now() - remoteBranchesStartTime}ms`);
           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)({
+        const branchesWithTimestamps = await Promise.all(allBranches.map(async (ancestorBranch) => {
+          let timestamp = await (0, exports.extractBranchingTimestamp)({
             branchName: gitBranchName,
             parentBranchName: ancestorBranch,
             execOptions,
             logger
           });
+          if (!timestamp) {
+            timestamp = await (0, exports.extractBranchingTimestamp)({
+              branchName: gitBranchName,
+              parentBranchName: ancestorBranch,
+              execOptions,
+              logger
+            });
+          }
+          if (!timestamp) {
+            const tip = await executeWithLog((0, shell_quote_1.quote)(["git", "show", "-s", "--format=%aI", ancestorBranch]), {
+              execOptions,
+              logger
+            });
+            const tipTimestamp = tip.stdout.trim();
+            if (!tip.stderr && isISODate(tipTimestamp)) {
+              logger.log(`No branching timestamp for confirmed ancestor '${ancestorBranch}', using tip commit date ${tipTimestamp}`);
+              timestamp = tipTimestamp;
+            }
+          }
           return timestamp ? { branchName: ancestorBranch, latestViableTimestamp: timestamp } : null;
         }));
-        logger.log(`[PERF] Timestamp extraction took ${Date.now() - timestampStartTime}ms`);
+        if (isDebugMode())
+          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) {
@@ -130004,35 +131052,22 @@ var require_extract_git_info = __commonJS({
           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
-            });
+            let branchesContainingRootResult = await executeWithLog((0, shell_quote_1.quote)(["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
-              });
+              branchesContainingRootResult = await executeWithLog((0, shell_quote_1.quote)(["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 (branchesContainingRoot.includes(defaultBranch)) {
+                rootBranch = defaultBranch;
+                logger.log(`Found root branch via detected defaultBranch: ${rootBranch}`);
               }
               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
-                    });
+                    const branchTimestampResult = await executeWithLog((0, shell_quote_1.quote)(["git", "log", "-1", "--format=%aI", branch]), { execOptions, logger });
                     return {
                       branch,
                       timestamp: branchTimestampResult.stdout.trim()
@@ -130051,12 +131086,19 @@ var require_extract_git_info = __commonJS({
                 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 isAncestorResult = await executeWithLog((0, shell_quote_1.quote)(["git", "merge-base", "--is-ancestor", rootBranch, gitBranchName]), { execOptions, logger });
+                    let accepted = isAncestorResult.code === 0;
+                    if (!accepted && rootBranch === defaultBranch) {
+                      const sharedHistory = await executeWithLog((0, shell_quote_1.quote)(["git", "merge-base", rootBranch, gitBranchName]), { execOptions, logger });
+                      if (!sharedHistory.stderr && sharedHistory.stdout.trim()) {
+                        accepted = true;
+                        logger.log(`Root branch ${rootBranch} is the advanced base, adding it as final fallback`);
+                      }
+                    }
+                    if (accepted) {
+                      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,
@@ -130085,7 +131127,9 @@ var require_extract_git_info = __commonJS({
         } 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`);
+        if (isDebugMode()) {
+          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) {
@@ -130950,7 +131994,7 @@ var require_package3 = __commonJS({
   "../core/package.json"(exports, module) {
     module.exports = {
       name: "@applitools/core",
-      version: "4.65.1",
+      version: "4.66.0",
       homepage: "https://applitools.com",
       bugs: {
         url: "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -131028,6 +132072,7 @@ var require_package3 = __commonJS({
         chalk: "4.1.2",
         "node-fetch": "2.6.7",
         semver: "7.6.2",
+        "shell-quote": "^1.8.4",
         throat: "6.0.2"
       },
       devDependencies: {
@@ -131044,6 +132089,7 @@ var require_package3 = __commonJS({
         "@types/node": "^12.20.55",
         "@types/selenium-webdriver": "^4.1.2",
         "@types/semver": "^7.5.8",
+        "@types/shell-quote": "^1",
         chai: "^4.2.0",
         chromedriver: "^131.0.5",
         crypto: "^1.0.1",
@@ -132502,7 +133548,7 @@ var require_package4 = __commonJS({
   "../eyes/package.json"(exports, module) {
     module.exports = {
       name: "@applitools/eyes",
-      version: "1.43.3",
+      version: "1.43.5",
       keywords: [
         "applitools",
         "eyes",
@@ -134118,7 +135164,7 @@ var require_package5 = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@applitools/eyes-browser",
-      version: "1.6.22",
+      version: "1.6.24",
       type: "module",
       keywords: [
         "applitools",