From d1bd5ec7b0d24e2aece3fc1fb9d8761318d83943 Mon Sep 17 00:00:00 2001
From: Mario Campos <mario-campos@github.com>
Date: Fri, 19 Jun 2026 16:07:35 -0500
Subject: [PATCH] Add logging for command cache file read/write failures

---
 lib/entry-points.js | 2283 ++++++++++++++++++++++---------------------
 src/cache.ts        |   10 +-
 2 files changed, 1149 insertions(+), 1144 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index fda1030e2..965223138 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -22743,20 +22743,20 @@ var dist_src_exports = {};
 __export(dist_src_exports, {
   Octokit: () => Octokit
 });
-function createLogger(logger = {}) {
-  if (typeof logger.debug !== "function") {
-    logger.debug = noop2;
+function createLogger(logger2 = {}) {
+  if (typeof logger2.debug !== "function") {
+    logger2.debug = noop2;
   }
-  if (typeof logger.info !== "function") {
-    logger.info = noop2;
+  if (typeof logger2.info !== "function") {
+    logger2.info = noop2;
   }
-  if (typeof logger.warn !== "function") {
-    logger.warn = consoleWarn;
+  if (typeof logger2.warn !== "function") {
+    logger2.warn = consoleWarn;
   }
-  if (typeof logger.error !== "function") {
-    logger.error = consoleError;
+  if (typeof logger2.error !== "function") {
+    logger2.error = consoleError;
   }
-  return logger;
+  return logger2;
 }
 var noop2, consoleWarn, consoleError, userAgentTrail, Octokit;
 var init_dist_src2 = __esm({
@@ -34908,9 +34908,9 @@ var require_logger = __commonJS({
         }
         logLevel = level;
         const enabledNamespaces = [];
-        for (const logger of registeredLoggers) {
-          if (shouldEnable(logger)) {
-            enabledNamespaces.push(logger.namespace);
+        for (const logger2 of registeredLoggers) {
+          if (shouldEnable(logger2)) {
+            enabledNamespaces.push(logger2.namespace);
           }
         }
         debug_js_1.default.enable(enabledNamespaces.join(","));
@@ -34922,20 +34922,20 @@ var require_logger = __commonJS({
           console.error(`${options.logLevelEnvVarName} set to unknown log level '${logLevelFromEnv}'; logging is not enabled. Acceptable values: ${TYPESPEC_RUNTIME_LOG_LEVELS.join(", ")}.`);
         }
       }
-      function shouldEnable(logger) {
-        return Boolean(logLevel && levelMap[logger.level] <= levelMap[logLevel]);
+      function shouldEnable(logger2) {
+        return Boolean(logLevel && levelMap[logger2.level] <= levelMap[logLevel]);
       }
       function createLogger2(parent, level) {
-        const logger = Object.assign(parent.extend(level), {
+        const logger2 = Object.assign(parent.extend(level), {
           level
         });
-        patchLogMethod(parent, logger);
-        if (shouldEnable(logger)) {
+        patchLogMethod(parent, logger2);
+        if (shouldEnable(logger2)) {
           const enabledNamespaces = debug_js_1.default.disable();
-          debug_js_1.default.enable(enabledNamespaces + "," + logger.namespace);
+          debug_js_1.default.enable(enabledNamespaces + "," + logger2.namespace);
         }
-        registeredLoggers.add(logger);
-        return logger;
+        registeredLoggers.add(logger2);
+        return logger2;
       }
       function contextGetLogLevel() {
         return logLevel;
@@ -35964,7 +35964,7 @@ var require_logPolicy = __commonJS({
     var sanitizer_js_1 = require_sanitizer();
     exports2.logPolicyName = "logPolicy";
     function logPolicy(options = {}) {
-      const logger = options.logger ?? log_js_1.logger.info;
+      const logger2 = options.logger ?? log_js_1.logger.info;
       const sanitizer = new sanitizer_js_1.Sanitizer({
         additionalAllowedHeaderNames: options.additionalAllowedHeaderNames,
         additionalAllowedQueryParameters: options.additionalAllowedQueryParameters
@@ -35972,13 +35972,13 @@ var require_logPolicy = __commonJS({
       return {
         name: exports2.logPolicyName,
         async sendRequest(request3, next) {
-          if (!logger.enabled) {
+          if (!logger2.enabled) {
             return next(request3);
           }
-          logger(`Request: ${sanitizer.sanitize(request3)}`);
+          logger2(`Request: ${sanitizer.sanitize(request3)}`);
           const response = await next(request3);
-          logger(`Response status code: ${response.status}`);
-          logger(`Headers: ${sanitizer.sanitize(response.headers)}`);
+          logger2(`Response status code: ${response.status}`);
+          logger2(`Headers: ${sanitizer.sanitize(response.headers)}`);
           return response;
         }
       };
@@ -36338,7 +36338,7 @@ var require_retryPolicy = __commonJS({
     var retryPolicyLogger = (0, logger_js_1.createClientLogger)("ts-http-runtime retryPolicy");
     var retryPolicyName = "retryPolicy";
     function retryPolicy(strategies, options = { maxRetries: constants_js_1.DEFAULT_RETRY_POLICY_COUNT }) {
-      const logger = options.logger || retryPolicyLogger;
+      const logger2 = options.logger || retryPolicyLogger;
       return {
         name: retryPolicyName,
         async sendRequest(request3, next) {
@@ -36350,11 +36350,11 @@ var require_retryPolicy = __commonJS({
             response = void 0;
             responseError = void 0;
             try {
-              logger.info(`Retry ${retryCount}: Attempting to send request`, request3.requestId);
+              logger2.info(`Retry ${retryCount}: Attempting to send request`, request3.requestId);
               response = await next(request3);
-              logger.info(`Retry ${retryCount}: Received a response from request`, request3.requestId);
+              logger2.info(`Retry ${retryCount}: Received a response from request`, request3.requestId);
             } catch (e) {
-              logger.error(`Retry ${retryCount}: Received an error from request`, request3.requestId);
+              logger2.error(`Retry ${retryCount}: Received an error from request`, request3.requestId);
               responseError = e;
               if (!e || responseError.name !== "RestError") {
                 throw e;
@@ -36362,12 +36362,12 @@ var require_retryPolicy = __commonJS({
               response = responseError.response;
             }
             if (request3.abortSignal?.aborted) {
-              logger.error(`Retry ${retryCount}: Request aborted.`);
+              logger2.error(`Retry ${retryCount}: Request aborted.`);
               const abortError = new AbortError_js_1.AbortError();
               throw abortError;
             }
             if (retryCount >= (options.maxRetries ?? constants_js_1.DEFAULT_RETRY_POLICY_COUNT)) {
-              logger.info(`Retry ${retryCount}: Maximum retries reached. Returning the last received response, or throwing the last received error.`);
+              logger2.info(`Retry ${retryCount}: Maximum retries reached. Returning the last received response, or throwing the last received error.`);
               if (responseError) {
                 throw responseError;
               } else if (response) {
@@ -36376,9 +36376,9 @@ var require_retryPolicy = __commonJS({
                 throw new Error("Maximum retries reached with no response or error to throw");
               }
             }
-            logger.info(`Retry ${retryCount}: Processing ${strategies.length} retry strategies.`);
+            logger2.info(`Retry ${retryCount}: Processing ${strategies.length} retry strategies.`);
             strategiesLoop: for (const strategy of strategies) {
-              const strategyLogger = strategy.logger || logger;
+              const strategyLogger = strategy.logger || logger2;
               strategyLogger.info(`Retry ${retryCount}: Processing retry strategy ${strategy.name}.`);
               const modifiers = strategy.retry({
                 retryCount,
@@ -36406,11 +36406,11 @@ var require_retryPolicy = __commonJS({
               }
             }
             if (responseError) {
-              logger.info(`None of the retry strategies could work with the received error. Throwing it.`);
+              logger2.info(`None of the retry strategies could work with the received error. Throwing it.`);
               throw responseError;
             }
             if (response) {
-              logger.info(`None of the retry strategies could work with the received response. Returning it.`);
+              logger2.info(`None of the retry strategies could work with the received response. Returning it.`);
               return response;
             }
           }
@@ -40846,7 +40846,7 @@ var require_bearerTokenAuthenticationPolicy = __commonJS({
     }
     function bearerTokenAuthenticationPolicy(options) {
       const { credential, scopes, challengeCallbacks } = options;
-      const logger = options.logger || log_js_1.logger;
+      const logger2 = options.logger || log_js_1.logger;
       const callbacks = {
         authorizeRequest: challengeCallbacks?.authorizeRequest?.bind(challengeCallbacks) ?? defaultAuthorizeRequest,
         authorizeRequestOnChallenge: challengeCallbacks?.authorizeRequestOnChallenge?.bind(challengeCallbacks)
@@ -40878,7 +40878,7 @@ var require_bearerTokenAuthenticationPolicy = __commonJS({
             scopes: Array.isArray(scopes) ? scopes : [scopes],
             request: request3,
             getAccessToken,
-            logger
+            logger: logger2
           });
           let response;
           let error3;
@@ -40891,7 +40891,7 @@ var require_bearerTokenAuthenticationPolicy = __commonJS({
               try {
                 parsedClaim = atob(claims);
               } catch (e) {
-                logger.warning(`The WWW-Authenticate header contains "claims" that cannot be parsed. Unable to perform the Continuous Access Evaluation authentication flow. Unparsable claims: ${claims}`);
+                logger2.warning(`The WWW-Authenticate header contains "claims" that cannot be parsed. Unable to perform the Continuous Access Evaluation authentication flow. Unparsable claims: ${claims}`);
                 return response;
               }
               shouldSendRequest = await authorizeRequestOnCaeChallenge({
@@ -40899,7 +40899,7 @@ var require_bearerTokenAuthenticationPolicy = __commonJS({
                 response,
                 request: request3,
                 getAccessToken,
-                logger
+                logger: logger2
               }, parsedClaim);
               if (shouldSendRequest) {
                 [response, error3] = await trySendRequest(request3, next);
@@ -40910,7 +40910,7 @@ var require_bearerTokenAuthenticationPolicy = __commonJS({
                 request: request3,
                 response,
                 getAccessToken,
-                logger
+                logger: logger2
               });
               if (shouldSendRequest) {
                 [response, error3] = await trySendRequest(request3, next);
@@ -40922,7 +40922,7 @@ var require_bearerTokenAuthenticationPolicy = __commonJS({
                   try {
                     parsedClaim = atob(claims);
                   } catch (e) {
-                    logger.warning(`The WWW-Authenticate header contains "claims" that cannot be parsed. Unable to perform the Continuous Access Evaluation authentication flow. Unparsable claims: ${claims}`);
+                    logger2.warning(`The WWW-Authenticate header contains "claims" that cannot be parsed. Unable to perform the Continuous Access Evaluation authentication flow. Unparsable claims: ${claims}`);
                     return response;
                   }
                   shouldSendRequest = await authorizeRequestOnCaeChallenge({
@@ -40930,7 +40930,7 @@ var require_bearerTokenAuthenticationPolicy = __commonJS({
                     response,
                     request: request3,
                     getAccessToken,
-                    logger
+                    logger: logger2
                   }, parsedClaim);
                   if (shouldSendRequest) {
                     [response, error3] = await trySendRequest(request3, next);
@@ -41020,7 +41020,7 @@ var require_auxiliaryAuthenticationHeaderPolicy = __commonJS({
     }
     function auxiliaryAuthenticationHeaderPolicy(options) {
       const { credentials, scopes } = options;
-      const logger = options.logger || log_js_1.logger;
+      const logger2 = options.logger || log_js_1.logger;
       const tokenCyclerMap = /* @__PURE__ */ new WeakMap();
       return {
         name: exports2.auxiliaryAuthenticationHeaderPolicyName,
@@ -41029,7 +41029,7 @@ var require_auxiliaryAuthenticationHeaderPolicy = __commonJS({
             throw new Error("Bearer token authentication for auxiliary header is not permitted for non-TLS protected (non-https) URLs.");
           }
           if (!credentials || credentials.length === 0) {
-            logger.info(`${exports2.auxiliaryAuthenticationHeaderPolicyName} header will not be set due to empty credentials.`);
+            logger2.info(`${exports2.auxiliaryAuthenticationHeaderPolicyName} header will not be set due to empty credentials.`);
             return next(request3);
           }
           const tokenPromises = [];
@@ -41043,12 +41043,12 @@ var require_auxiliaryAuthenticationHeaderPolicy = __commonJS({
               scopes: Array.isArray(scopes) ? scopes : [scopes],
               request: request3,
               getAccessToken,
-              logger
+              logger: logger2
             }));
           }
           const auxiliaryTokens = (await Promise.all(tokenPromises)).filter((token) => Boolean(token));
           if (auxiliaryTokens.length === 0) {
-            logger.warning(`None of the auxiliary tokens are valid. ${AUTHORIZATION_AUXILIARY_HEADER} header will not be set.`);
+            logger2.warning(`None of the auxiliary tokens are valid. ${AUTHORIZATION_AUXILIARY_HEADER} header will not be set.`);
             return next(request3);
           }
           request3.headers.set(AUTHORIZATION_AUXILIARY_HEADER, auxiliaryTokens.map((token) => `Bearer ${token}`).join(", "));
@@ -43245,16 +43245,16 @@ var require_authorizeRequestOnClaimChallenge = __commonJS({
     }
     async function authorizeRequestOnClaimChallenge(onChallengeOptions) {
       const { scopes, response } = onChallengeOptions;
-      const logger = onChallengeOptions.logger || log_js_1.logger;
+      const logger2 = onChallengeOptions.logger || log_js_1.logger;
       const challenge = response.headers.get("WWW-Authenticate");
       if (!challenge) {
-        logger.info(`The WWW-Authenticate header was missing. Failed to perform the Continuous Access Evaluation authentication flow.`);
+        logger2.info(`The WWW-Authenticate header was missing. Failed to perform the Continuous Access Evaluation authentication flow.`);
         return false;
       }
       const challenges = parseCAEChallenge(challenge) || [];
       const parsedChallenge = challenges.find((x) => x.claims);
       if (!parsedChallenge) {
-        logger.info(`The WWW-Authenticate header was missing the necessary "claims" to perform the Continuous Access Evaluation authentication flow.`);
+        logger2.info(`The WWW-Authenticate header was missing the necessary "claims" to perform the Continuous Access Evaluation authentication flow.`);
         return false;
       }
       const accessToken = await onChallengeOptions.getAccessToken(parsedChallenge.scope ? [parsedChallenge.scope] : scopes, {
@@ -116273,20 +116273,20 @@ var require_dist_node8 = __commonJS({
     };
     var consoleWarn2 = console.warn.bind(console);
     var consoleError2 = console.error.bind(console);
-    function createLogger2(logger = {}) {
-      if (typeof logger.debug !== "function") {
-        logger.debug = noop3;
+    function createLogger2(logger2 = {}) {
+      if (typeof logger2.debug !== "function") {
+        logger2.debug = noop3;
       }
-      if (typeof logger.info !== "function") {
-        logger.info = noop3;
+      if (typeof logger2.info !== "function") {
+        logger2.info = noop3;
       }
-      if (typeof logger.warn !== "function") {
-        logger.warn = consoleWarn2;
+      if (typeof logger2.warn !== "function") {
+        logger2.warn = consoleWarn2;
       }
-      if (typeof logger.error !== "function") {
-        logger.error = consoleError2;
+      if (typeof logger2.error !== "function") {
+        logger2.error = consoleError2;
       }
-      return logger;
+      return logger2;
     }
     var userAgentTrail2 = `octokit-core.js/${VERSION8} ${(0, import_universal_user_agent5.getUserAgent)()}`;
     var Octokit2 = class {
@@ -143715,13 +143715,13 @@ var require_log7 = __commonJS({
     forge.log.logMessage = function(message) {
       var messageLevelIndex = sLevelInfo[message.level].index;
       for (var i2 = 0; i2 < sLoggers.length; ++i2) {
-        var logger2 = sLoggers[i2];
-        if (logger2.flags & forge.log.NO_LEVEL_CHECK) {
-          logger2.f(message);
+        var logger3 = sLoggers[i2];
+        if (logger3.flags & forge.log.NO_LEVEL_CHECK) {
+          logger3.f(message);
         } else {
-          var loggerLevelIndex = sLevelInfo[logger2.level].index;
+          var loggerLevelIndex = sLevelInfo[logger3.level].index;
           if (messageLevelIndex <= loggerLevelIndex) {
-            logger2.f(logger2, message);
+            logger3.f(logger3, message);
           }
         }
       }
@@ -143769,20 +143769,20 @@ var require_log7 = __commonJS({
     var levels;
     var i;
     forge.log.makeLogger = function(logFunction) {
-      var logger2 = {
+      var logger3 = {
         flags: 0,
         f: logFunction
       };
-      forge.log.setLevel(logger2, "none");
-      return logger2;
+      forge.log.setLevel(logger3, "none");
+      return logger3;
     };
-    forge.log.setLevel = function(logger2, level2) {
+    forge.log.setLevel = function(logger3, level2) {
       var rval = false;
-      if (logger2 && !(logger2.flags & forge.log.LEVEL_LOCKED)) {
+      if (logger3 && !(logger3.flags & forge.log.LEVEL_LOCKED)) {
         for (var i2 = 0; i2 < forge.log.levels.length; ++i2) {
           var aValidLevel = forge.log.levels[i2];
           if (level2 == aValidLevel) {
-            logger2.level = level2;
+            logger3.level = level2;
             rval = true;
             break;
           }
@@ -143790,15 +143790,15 @@ var require_log7 = __commonJS({
       }
       return rval;
     };
-    forge.log.lock = function(logger2, lock2) {
+    forge.log.lock = function(logger3, lock2) {
       if (typeof lock2 === "undefined" || lock2) {
-        logger2.flags |= forge.log.LEVEL_LOCKED;
+        logger3.flags |= forge.log.LEVEL_LOCKED;
       } else {
-        logger2.flags &= ~forge.log.LEVEL_LOCKED;
+        logger3.flags &= ~forge.log.LEVEL_LOCKED;
       }
     };
-    forge.log.addLogger = function(logger2) {
-      sLoggers.push(logger2);
+    forge.log.addLogger = function(logger3) {
+      sLoggers.push(logger3);
     };
     if (typeof console !== "undefined" && "log" in console) {
       if (console.error && console.warn && console.info && console.debug) {
@@ -143809,31 +143809,31 @@ var require_log7 = __commonJS({
           debug: console.debug,
           verbose: console.debug
         };
-        f = function(logger2, message) {
+        f = function(logger3, message) {
           forge.log.prepareStandard(message);
           var handler2 = levelHandlers[message.level];
           var args = [message.standard];
           args = args.concat(message["arguments"].slice());
           handler2.apply(console, args);
         };
-        logger = forge.log.makeLogger(f);
+        logger2 = forge.log.makeLogger(f);
       } else {
-        f = function(logger2, message) {
+        f = function(logger3, message) {
           forge.log.prepareStandardFull(message);
           console.log(message.standardFull);
         };
-        logger = forge.log.makeLogger(f);
+        logger2 = forge.log.makeLogger(f);
       }
-      forge.log.setLevel(logger, "debug");
-      forge.log.addLogger(logger);
-      sConsoleLogger = logger;
+      forge.log.setLevel(logger2, "debug");
+      forge.log.addLogger(logger2);
+      sConsoleLogger = logger2;
     } else {
       console = {
         log: function() {
         }
       };
     }
-    var logger;
+    var logger2;
     var levelHandlers;
     var f;
     if (sConsoleLogger !== null && typeof window !== "undefined" && window.location) {
@@ -147609,74 +147609,74 @@ function getMemoryFlagValueForPlatform(userInput, totalMemoryBytes, platform2) {
   }
   return Math.floor(memoryToUseMegaBytes);
 }
-function getTotalMemoryBytes(logger) {
+function getTotalMemoryBytes(logger2) {
   const limits = [os.totalmem()];
   if (os.platform() === "linux") {
     limits.push(
       ...[
         "/sys/fs/cgroup/memory/memory.limit_in_bytes",
         "/sys/fs/cgroup/memory.max"
-      ].map((file) => getCgroupMemoryLimitBytes(file, logger)).filter((limit2) => limit2 !== void 0).map((limit2) => limit2)
+      ].map((file) => getCgroupMemoryLimitBytes(file, logger2)).filter((limit2) => limit2 !== void 0).map((limit2) => limit2)
     );
   }
   const limit = Math.min(...limits);
-  logger.debug(
+  logger2.debug(
     `While resolving RAM, determined that the total memory available to the Action is ${limit / (1024 * 1024)} MiB.`
   );
   return limit;
 }
-function getCgroupMemoryLimitBytes(limitFile, logger) {
+function getCgroupMemoryLimitBytes(limitFile, logger2) {
   if (!fs.existsSync(limitFile)) {
-    logger.debug(
+    logger2.debug(
       `While resolving RAM, did not find a cgroup memory limit at ${limitFile}.`
     );
     return void 0;
   }
   const limit = Number(fs.readFileSync(limitFile, "utf8"));
   if (!Number.isInteger(limit)) {
-    logger.debug(
+    logger2.debug(
       `While resolving RAM, ignored the file ${limitFile} that may contain a cgroup memory limit as this file did not contain an integer.`
     );
     return void 0;
   }
   const displayLimit = `${Math.floor(limit / (1024 * 1024))} MiB`;
   if (limit > os.totalmem()) {
-    logger.debug(
+    logger2.debug(
       `While resolving RAM, ignored the file ${limitFile} that may contain a cgroup memory limit as its contents ${displayLimit} were greater than the total amount of system memory.`
     );
     return void 0;
   }
   if (limit < MINIMUM_CGROUP_MEMORY_LIMIT_BYTES) {
-    logger.info(
+    logger2.info(
       `While resolving RAM, ignored a cgroup limit of ${displayLimit} in ${limitFile} as it was below ${MINIMUM_CGROUP_MEMORY_LIMIT_BYTES / (1024 * 1024)} MiB.`
     );
     return void 0;
   }
-  logger.info(
+  logger2.info(
     `While resolving RAM, found a cgroup limit of ${displayLimit} in ${limitFile}.`
   );
   return limit;
 }
-function getCodeQLMemoryLimit(userInput, logger) {
+function getCodeQLMemoryLimit(userInput, logger2) {
   return getMemoryFlagValueForPlatform(
     userInput,
-    getTotalMemoryBytes(logger),
+    getTotalMemoryBytes(logger2),
     process.platform
   );
 }
-function getMemoryFlag(userInput, logger) {
-  const megabytes = getCodeQLMemoryLimit(userInput, logger);
+function getMemoryFlag(userInput, logger2) {
+  const megabytes = getCodeQLMemoryLimit(userInput, logger2);
   return `--ram=${megabytes}`;
 }
-function getThreadsFlagValue(userInput, logger) {
+function getThreadsFlagValue(userInput, logger2) {
   let numThreads;
   const maxThreadsCandidates = [os.cpus().length];
   if (os.platform() === "linux") {
     maxThreadsCandidates.push(
-      ...["/sys/fs/cgroup/cpuset.cpus.effective", "/sys/fs/cgroup/cpuset.cpus"].map((file) => getCgroupCpuCountFromCpus(file, logger)).filter((count) => count !== void 0 && count > 0).map((count) => count)
+      ...["/sys/fs/cgroup/cpuset.cpus.effective", "/sys/fs/cgroup/cpuset.cpus"].map((file) => getCgroupCpuCountFromCpus(file, logger2)).filter((count) => count !== void 0 && count > 0).map((count) => count)
     );
     maxThreadsCandidates.push(
-      ...["/sys/fs/cgroup/cpu.max"].map((file) => getCgroupCpuCountFromCpuMax(file, logger)).filter((count) => count !== void 0 && count > 0).map((count) => count)
+      ...["/sys/fs/cgroup/cpu.max"].map((file) => getCgroupCpuCountFromCpuMax(file, logger2)).filter((count) => count !== void 0 && count > 0).map((count) => count)
     );
   }
   const maxThreads = Math.min(...maxThreadsCandidates);
@@ -147688,14 +147688,14 @@ function getThreadsFlagValue(userInput, logger) {
       );
     }
     if (numThreads > maxThreads) {
-      logger.info(
+      logger2.info(
         `Clamping desired number of threads (${numThreads}) to max available (${maxThreads}).`
       );
       numThreads = maxThreads;
     }
     const minThreads = -maxThreads;
     if (numThreads < minThreads) {
-      logger.info(
+      logger2.info(
         `Clamping desired number of free threads (${numThreads}) to max available (${minThreads}).`
       );
       numThreads = minThreads;
@@ -147705,9 +147705,9 @@ function getThreadsFlagValue(userInput, logger) {
   }
   return numThreads;
 }
-function getCgroupCpuCountFromCpuMax(cpuMaxFile, logger) {
+function getCgroupCpuCountFromCpuMax(cpuMaxFile, logger2) {
   if (!fs.existsSync(cpuMaxFile)) {
-    logger.debug(
+    logger2.debug(
       `While resolving threads, did not find a cgroup CPU file at ${cpuMaxFile}.`
     );
     return void 0;
@@ -147715,7 +147715,7 @@ function getCgroupCpuCountFromCpuMax(cpuMaxFile, logger) {
   const cpuMaxString = fs.readFileSync(cpuMaxFile, "utf-8");
   const cpuMaxStringSplit = cpuMaxString.split(" ");
   if (cpuMaxStringSplit.length !== 2) {
-    logger.debug(
+    logger2.debug(
       `While resolving threads, did not use cgroup CPU file at ${cpuMaxFile} because it contained ${cpuMaxStringSplit.length} value(s) rather than the two expected.`
     );
     return void 0;
@@ -147726,14 +147726,14 @@ function getCgroupCpuCountFromCpuMax(cpuMaxFile, logger) {
   }
   const duration = cpuMaxStringSplit[1];
   const cpuCount = Math.floor(parseInt(cpuLimit) / parseInt(duration));
-  logger.info(
+  logger2.info(
     `While resolving threads, found a cgroup CPU file with ${cpuCount} CPUs in ${cpuMaxFile}.`
   );
   return cpuCount;
 }
-function getCgroupCpuCountFromCpus(cpusFile, logger) {
+function getCgroupCpuCountFromCpus(cpusFile, logger2) {
   if (!fs.existsSync(cpusFile)) {
-    logger.debug(
+    logger2.debug(
       `While resolving threads, did not find a cgroup CPUs file at ${cpusFile}.`
     );
     return void 0;
@@ -147752,13 +147752,13 @@ function getCgroupCpuCountFromCpus(cpusFile, logger) {
       cpuCount += cpuEndIndex - cpuStartIndex + 1;
     }
   }
-  logger.info(
+  logger2.info(
     `While resolving threads, found a cgroup CPUs file with ${cpuCount} CPUs in ${cpusFile}.`
   );
   return cpuCount;
 }
-function getThreadsFlag(userInput, logger) {
-  return `--threads=${getThreadsFlagValue(userInput, logger)}`;
+function getThreadsFlag(userInput, logger2) {
+  return `--threads=${getThreadsFlagValue(userInput, logger2)}`;
 }
 function getCodeQLDatabasePath(config, language) {
   return path.resolve(config.dbLocation, language);
@@ -147801,7 +147801,7 @@ function parseGitHubUrl(inputUrl) {
 }
 var CODEQL_ACTION_WARNED_ABOUT_VERSION_ENV_VAR = "CODEQL_ACTION_WARNED_ABOUT_VERSION";
 var hasBeenWarnedAboutVersion = false;
-function checkGitHubVersionInRange(version, logger) {
+function checkGitHubVersionInRange(version, logger2) {
   if (hasBeenWarnedAboutVersion || version.type !== "GitHub Enterprise Server" /* GHES */) {
     return;
   }
@@ -147811,12 +147811,12 @@ function checkGitHubVersionInRange(version, logger) {
     maximumVersion
   );
   if (disallowedAPIVersionReason === 0 /* ACTION_TOO_OLD */) {
-    logger.warning(
+    logger2.warning(
       `The CodeQL Action version you are using is too old to be compatible with GitHub Enterprise ${version.version}. If you experience issues, please upgrade to a more recent version of the CodeQL Action.`
     );
   }
   if (disallowedAPIVersionReason === 1 /* ACTION_TOO_NEW */) {
-    logger.warning(
+    logger2.warning(
       `GitHub Enterprise ${version.version} is too old to be compatible with this version of the CodeQL Action. If you experience issues, please upgrade to a more recent version of GitHub Enterprise or use an older version of the CodeQL Action.`
     );
   }
@@ -147962,12 +147962,12 @@ function listFolder(dir) {
   }
   return files;
 }
-async function tryGetFolderBytes(cacheDir2, logger, quiet = false) {
+async function tryGetFolderBytes(cacheDir2, logger2, quiet = false) {
   try {
     return await getFolderSize.loose(cacheDir2);
   } catch (e) {
-    if (!quiet || logger.isDebug()) {
-      logger.warning(
+    if (!quiet || logger2.isDebug()) {
+      logger2.warning(
         `Encountered an error while getting size of '${cacheDir2}': ${e}`
       );
     }
@@ -148024,7 +148024,7 @@ function getErrorMessage(error3) {
 function prettyPrintPack(pack) {
   return `${pack.name}${pack.version ? `@${pack.version}` : ""}${pack.path ? `:${pack.path}` : ""}`;
 }
-async function checkDiskUsage(logger) {
+async function checkDiskUsage(logger2) {
   try {
     const diskUsage = await fsPromises.statfs(
       getRequiredEnvParam("GITHUB_WORKSPACE")
@@ -148035,9 +148035,9 @@ async function checkDiskUsage(logger) {
     if (diskUsage.bavail < 2 * numBlocksPerGb) {
       const message = `The Actions runner is running low on disk space (${(diskUsage.bavail / numBlocksPerMb).toPrecision(4)} MB available).`;
       if (process.env["CODEQL_ACTION_HAS_WARNED_ABOUT_DISK_SPACE" /* HAS_WARNED_ABOUT_DISK_SPACE */] !== "true") {
-        logger.warning(message);
+        logger2.warning(message);
       } else {
-        logger.debug(message);
+        logger2.debug(message);
       }
       core2.exportVariable("CODEQL_ACTION_HAS_WARNED_ABOUT_DISK_SPACE" /* HAS_WARNED_ABOUT_DISK_SPACE */, "true");
     }
@@ -148046,7 +148046,7 @@ async function checkDiskUsage(logger) {
       numTotalBytes: diskUsage.blocks * blockSizeInBytes
     };
   } catch (error3) {
-    logger.warning(
+    logger2.warning(
       `Failed to check available disk space: ${getErrorMessage(error3)}`
     );
     return void 0;
@@ -148083,24 +148083,24 @@ var BuildMode = /* @__PURE__ */ ((BuildMode3) => {
 function cloneObject(obj) {
   return JSON.parse(JSON.stringify(obj));
 }
-async function cleanUpPath(file, name, logger) {
-  logger.debug(`Cleaning up ${name}.`);
+async function cleanUpPath(file, name, logger2) {
+  logger2.debug(`Cleaning up ${name}.`);
   try {
     await fs.promises.rm(file, {
       force: true,
       recursive: true
     });
   } catch (e) {
-    logger.warning(`Failed to clean up ${name}: ${e}.`);
+    logger2.warning(`Failed to clean up ${name}: ${e}.`);
   }
 }
-async function isBinaryAccessible(binary, logger) {
+async function isBinaryAccessible(binary, logger2) {
   try {
     await io.which(binary, true);
-    logger.debug(`Found ${binary}.`);
+    logger2.debug(`Found ${binary}.`);
     return true;
   } catch (e) {
-    logger.debug(`Could not find ${binary}: ${e}`);
+    logger2.debug(`Could not find ${binary}: ${e}`);
     return false;
   }
 }
@@ -148441,13 +148441,13 @@ var qualityCategoryMapping = {
   typescript: "javascript-typescript",
   kotlin: "java-kotlin"
 };
-function fixCodeQualityCategory(logger, category) {
+function fixCodeQualityCategory(logger2, category) {
   if (category !== void 0 && isDefaultSetup() && category.startsWith("/language:")) {
     const language = category.substring("/language:".length);
     const mappedLanguage = qualityCategoryMapping[language];
     if (mappedLanguage) {
       const newCategory = `/language:${mappedLanguage}`;
-      logger.info(
+      logger2.info(
         `Adjusted category for Code Quality from '${category}' to '${newCategory}'.`
       );
       return newCategory;
@@ -148599,12 +148599,12 @@ function getApiClient() {
 function getApiClientWithExternalAuth(apiDetails) {
   return createApiClientWithDetails(apiDetails, { allowExternal: true });
 }
-function getAuthorizationHeaderFor(logger, apiDetails, url2) {
+function getAuthorizationHeaderFor(logger2, apiDetails, url2) {
   if (url2.startsWith(`${apiDetails.url}/`) || apiDetails.apiURL && url2.startsWith(`${apiDetails.apiURL}/`)) {
-    logger.debug(`Providing an authorization token.`);
+    logger2.debug(`Providing an authorization token.`);
     return `token ${apiDetails.auth}`;
   }
-  logger.debug(`Not using an authorization token.`);
+  logger2.debug(`Not using an authorization token.`);
   return void 0;
 }
 var cachedGitHubVersion = void 0;
@@ -149038,7 +149038,7 @@ async function writeBaseDatabaseOidsFile(config, sourceRoot) {
   const baseDatabaseOidsFilePath = getBaseDatabaseOidsFilePath(config);
   await fs4.promises.writeFile(baseDatabaseOidsFilePath, gitFileOidsJson);
 }
-async function readBaseDatabaseOidsFile(config, logger) {
+async function readBaseDatabaseOidsFile(config, logger2) {
   const baseDatabaseOidsFilePath = getBaseDatabaseOidsFilePath(config);
   try {
     const contents = await fs4.promises.readFile(
@@ -149047,27 +149047,27 @@ async function readBaseDatabaseOidsFile(config, logger) {
     );
     return JSON.parse(contents);
   } catch (e) {
-    logger.error(
+    logger2.error(
       `Failed to read overlay-base file OIDs from ${baseDatabaseOidsFilePath}: ${e.message || e}`
     );
     throw e;
   }
 }
-async function writeOverlayChangesFile(config, sourceRoot, logger) {
-  const baseFileOids = await readBaseDatabaseOidsFile(config, logger);
+async function writeOverlayChangesFile(config, sourceRoot, logger2) {
+  const baseFileOids = await readBaseDatabaseOidsFile(config, logger2);
   const overlayFileOids = await getFileOidsUnderPath(sourceRoot);
   const oidChangedFiles = computeChangedFiles(baseFileOids, overlayFileOids);
-  logger.info(
+  logger2.info(
     `Found ${oidChangedFiles.length} changed file(s) under ${sourceRoot} from OID comparison.`
   );
-  const diffRangeFiles = await getDiffRangeFilePaths(sourceRoot, logger);
+  const diffRangeFiles = await getDiffRangeFilePaths(sourceRoot, logger2);
   const changedFiles = [.../* @__PURE__ */ new Set([...oidChangedFiles, ...diffRangeFiles])];
   const changedFilesJson = JSON.stringify({ changes: changedFiles });
   const overlayChangesFile = path4.join(
     getTemporaryDirectory(),
     "overlay-changes.json"
   );
-  logger.debug(
+  logger2.debug(
     `Writing overlay changed files to ${overlayChangesFile}: ${changedFilesJson}`
   );
   await fs4.promises.writeFile(overlayChangesFile, changedFilesJson);
@@ -149087,10 +149087,10 @@ function computeChangedFiles(baseFileOids, overlayFileOids) {
   }
   return changes;
 }
-async function getDiffRangeFilePaths(sourceRoot, logger) {
+async function getDiffRangeFilePaths(sourceRoot, logger2) {
   const jsonFilePath = getDiffRangesJsonFilePath();
   if (!fs4.existsSync(jsonFilePath)) {
-    logger.debug(
+    logger2.debug(
       `No diff ranges JSON file found at ${jsonFilePath}; skipping.`
     );
     return [];
@@ -149099,7 +149099,7 @@ async function getDiffRangeFilePaths(sourceRoot, logger) {
   try {
     contents = await fs4.promises.readFile(jsonFilePath, "utf8");
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to read diff ranges JSON file at ${jsonFilePath}: ${e}`
     );
     return [];
@@ -149108,12 +149108,12 @@ async function getDiffRangeFilePaths(sourceRoot, logger) {
   try {
     diffRanges = JSON.parse(contents);
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to parse diff ranges JSON file at ${jsonFilePath}: ${e}`
     );
     return [];
   }
-  logger.debug(
+  logger2.debug(
     `Read ${diffRanges.length} diff range(s) from ${jsonFilePath} for overlay changes.`
   );
   const repoRoot = await getGitRoot(sourceRoot);
@@ -149123,7 +149123,7 @@ async function getDiffRangeFilePaths(sourceRoot, logger) {
         "Cannot determine git root to convert diff range paths relative to source-root. Failing to avoid omitting files from the analysis."
       );
     }
-    logger.warning(
+    logger2.warning(
       "Cannot determine git root; returning diff range paths as-is."
     );
     return [...new Set(diffRanges.map((r) => r.path))];
@@ -149377,8 +149377,8 @@ var featureConfig = {
 };
 var FEATURE_FLAGS_FILE_NAME = "cached-feature-flags.json";
 var OfflineFeatures = class {
-  constructor(logger) {
-    this.logger = logger;
+  constructor(logger2) {
+    this.logger = logger2;
   }
   logger;
   async getEnabledDefaultCliVersions(_variant) {
@@ -149480,12 +149480,12 @@ var OfflineFeatures = class {
 };
 var Features = class extends OfflineFeatures {
   gitHubFeatureFlags;
-  constructor(repositoryNwo, tempDir, logger) {
-    super(logger);
+  constructor(repositoryNwo, tempDir, logger2) {
+    super(logger2);
     this.gitHubFeatureFlags = new GitHubFeatureFlags(
       repositoryNwo,
       path5.join(tempDir, FEATURE_FLAGS_FILE_NAME),
-      logger
+      logger2
     );
   }
   async getEnabledDefaultCliVersions(variant) {
@@ -149522,10 +149522,10 @@ var Features = class extends OfflineFeatures {
   }
 };
 var GitHubFeatureFlags = class {
-  constructor(repositoryNwo, featureFlagsFile, logger) {
+  constructor(repositoryNwo, featureFlagsFile, logger2) {
     this.repositoryNwo = repositoryNwo;
     this.featureFlagsFile = featureFlagsFile;
-    this.logger = logger;
+    this.logger = logger2;
     this.hasAccessedRemoteFeatureFlags = false;
   }
   repositoryNwo;
@@ -149693,14 +149693,14 @@ var GitHubFeatureFlags = class {
 function supportsFeatureFlags(githubVariant) {
   return githubVariant === "GitHub.com" /* DOTCOM */ || githubVariant === "GitHub Enterprise Cloud with data residency" /* GHEC_DR */;
 }
-function initFeatures(gitHubVersion, repositoryNwo, tempDir, logger) {
+function initFeatures(gitHubVersion, repositoryNwo, tempDir, logger2) {
   if (!supportsFeatureFlags(gitHubVersion.type)) {
-    logger.debug(
+    logger2.debug(
       "Not running against github.com. Using default values for all features."
     );
-    return new OfflineFeatures(logger);
+    return new OfflineFeatures(logger2);
   } else {
-    return new Features(repositoryNwo, tempDir, logger);
+    return new Features(repositoryNwo, tempDir, logger2);
   }
 }
 
@@ -149740,7 +149740,7 @@ function isOnlyCodeScanningEnabled(analysisKinds) {
 function makeAnalysisKindUsageError(message) {
   return `The \`analysis-kinds\` input is experimental and for GitHub-internal use only. Its behaviour may change at any time or be removed entirely. ${message}`;
 }
-async function getAnalysisKinds(logger, features, skipCache = false) {
+async function getAnalysisKinds(logger2, features, skipCache = false) {
   if (!skipCache && cachedAnalysisKinds !== void 0) {
     return cachedAnalysisKinds;
   }
@@ -149749,7 +149749,7 @@ async function getAnalysisKinds(logger, features, skipCache = false) {
   );
   if (!isInTestMode() && !isDynamicWorkflow() && !isOnlyCodeScanningEnabled(analysisKinds)) {
     const codeQualityHint = analysisKinds.includes("code-quality" /* CodeQuality */) ? " If your intention is to use quality queries outside of Code Quality, use the `queries` input with `code-quality` instead." : "";
-    logger.error(
+    logger2.error(
       makeAnalysisKindUsageError(
         `An analysis kind other than \`code-scanning\` was specified in a custom workflow. This is not supported and will become a fatal error in a future version of the CodeQL Action.${codeQualityHint}`
       )
@@ -149757,7 +149757,7 @@ async function getAnalysisKinds(logger, features, skipCache = false) {
   }
   const qualityQueriesInput = getOptionalInput("quality-queries");
   if (qualityQueriesInput !== void 0) {
-    logger.warning(
+    logger2.warning(
       "The `quality-queries` input is deprecated and will be removed in a future version of the CodeQL Action. Use the `analysis-kinds` input to configure different analysis kinds instead."
     );
   }
@@ -149775,7 +149775,7 @@ async function getAnalysisKinds(logger, features, skipCache = false) {
     }
   }
   if (!isInTestMode() && analysisKinds.length > 1 && !await features.getValue("allow_multiple_analysis_kinds" /* AllowMultipleAnalysisKinds */)) {
-    logger.error(
+    logger2.error(
       makeAnalysisKindUsageError(
         "Specifying multiple values as input is no longer supported. Continuing with only `analysis-kinds: code-scanning`."
       )
@@ -149866,12 +149866,56 @@ var toolrunner3 = __toESM(require_toolrunner());
 // src/cache.ts
 var fs6 = __toESM(require("fs"));
 var path6 = __toESM(require("path"));
+
+// src/logging.ts
+var core6 = __toESM(require_core());
+function getActionsLogger() {
+  return {
+    debug: core6.debug,
+    info: core6.info,
+    warning: core6.warning,
+    error: core6.error,
+    isDebug: core6.isDebug,
+    startGroup: core6.startGroup,
+    endGroup: core6.endGroup
+  };
+}
+function withGroup(groupName, f) {
+  core6.startGroup(groupName);
+  try {
+    return f();
+  } finally {
+    core6.endGroup();
+  }
+}
+async function withGroupAsync(groupName, f) {
+  core6.startGroup(groupName);
+  try {
+    return await f();
+  } finally {
+    core6.endGroup();
+  }
+}
+function formatDuration(durationMs) {
+  if (durationMs < 1e3) {
+    return `${durationMs}ms`;
+  }
+  if (durationMs < 60 * 1e3) {
+    return `${(durationMs / 1e3).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(durationMs / (60 * 1e3));
+  const seconds = Math.floor(durationMs % (60 * 1e3) / 1e3);
+  return `${minutes}m${seconds}s`;
+}
+
+// src/cache.ts
 var COMMAND_CACHE_FILENAME = "codeql-action-command-cache.json";
 var CommandCacheKey = {
   Version: "version",
   ResolveLanguages: "resolveLanguages"
 };
 var inMemoryCache = /* @__PURE__ */ new Map();
+var logger = getActionsLogger();
 function getCommandCacheFilePath() {
   return path6.join(getTemporaryDirectory(), COMMAND_CACHE_FILENAME);
 }
@@ -149885,14 +149929,16 @@ function readCommandCacheFile() {
     if (isObject(parsed)) {
       return parsed;
     }
-  } catch {
+  } catch (e) {
+    logger.warning(`Failed to read or parse command cache file: ${e}`);
   }
   return {};
 }
 function writeCommandCacheFile(data) {
   try {
     fs6.writeFileSync(getCommandCacheFilePath(), JSON.stringify(data));
-  } catch {
+  } catch (e) {
+    logger.warning(`Failed to write command cache file: ${e}`);
   }
 }
 function cacheCommandOutput(key, cmd, output) {
@@ -150176,10 +150222,10 @@ var core8 = __toESM(require_core());
 
 // src/caching-utils.ts
 var crypto2 = __toESM(require("crypto"));
-var core6 = __toESM(require_core());
-async function getTotalCacheSize(paths, logger, quiet = false) {
+var core7 = __toESM(require_core());
+async function getTotalCacheSize(paths, logger2, quiet = false) {
   const sizes = await Promise.all(
-    paths.map((cacheDir2) => tryGetFolderBytes(cacheDir2, logger, quiet))
+    paths.map((cacheDir2) => tryGetFolderBytes(cacheDir2, logger2, quiet))
   );
   return sizes.map((a) => a || 0).reduce((a, b) => a + b, 0);
 }
@@ -150205,7 +150251,7 @@ function getCachingKind(input) {
     case "restore":
       return "restore" /* Restore */;
     default:
-      core6.warning(
+      core7.warning(
         `Unrecognized 'dependency-caching' input: ${input}. Defaulting to 'none'.`
       );
       return "none" /* None */;
@@ -150309,7 +150355,7 @@ var repositoryPropertyParsers = {
   ["github-codeql-extra-queries" /* EXTRA_QUERIES */]: stringProperty,
   ["github-codeql-file-coverage-on-prs" /* FILE_COVERAGE_ON_PRS */]: booleanProperty
 };
-async function loadPropertiesFromApi(logger, repositoryNwo) {
+async function loadPropertiesFromApi(logger2, repositoryNwo) {
   try {
     const response = await getRepositoryProperties(repositoryNwo);
     const remoteProperties = response.data;
@@ -150318,7 +150364,7 @@ async function loadPropertiesFromApi(logger, repositoryNwo) {
         `Expected repository properties API to return an array, but got: ${JSON.stringify(response.data)}`
       );
     }
-    logger.debug(
+    logger2.debug(
       `Retrieved ${remoteProperties.length} repository properties: ${remoteProperties.map((p) => p.property_name).join(", ")}`
     );
     const properties = {};
@@ -150330,26 +150376,26 @@ async function loadPropertiesFromApi(logger, repositoryNwo) {
         );
       }
       if (isKnownPropertyName(property.property_name)) {
-        setProperty(properties, property.property_name, property.value, logger);
+        setProperty(properties, property.property_name, property.value, logger2);
       } else if (property.property_name.startsWith(GITHUB_CODEQL_PROPERTY_PREFIX) && !isDynamicWorkflow()) {
         unrecognisedProperties.push(property.property_name);
       }
     }
     if (Object.keys(properties).length === 0) {
-      logger.debug("No known repository properties were found.");
+      logger2.debug("No known repository properties were found.");
     } else {
-      logger.debug(
+      logger2.debug(
         "Loaded the following values for the repository properties:"
       );
       for (const [property, value] of Object.entries(properties).sort(
         ([nameA], [nameB]) => nameA.localeCompare(nameB)
       )) {
-        logger.debug(`  ${property}: ${value}`);
+        logger2.debug(`  ${property}: ${value}`);
       }
     }
     if (unrecognisedProperties.length > 0) {
       const unrecognisedPropertyList = unrecognisedProperties.map((name) => `'${name}'`).join(", ");
-      logger.warning(
+      logger2.warning(
         `Found repository properties (${unrecognisedPropertyList}), which look like CodeQL Action repository properties, but which are not understood by this version of the CodeQL Action. Do you need to update to a newer version?`
       );
     }
@@ -150360,19 +150406,19 @@ async function loadPropertiesFromApi(logger, repositoryNwo) {
     );
   }
 }
-function setProperty(properties, name, value, logger) {
+function setProperty(properties, name, value, logger2) {
   const propertyOptions = repositoryPropertyParsers[name];
   if (propertyOptions.validate(value)) {
-    properties[name] = propertyOptions.parse(name, value, logger);
+    properties[name] = propertyOptions.parse(name, value, logger2);
   } else {
     throw new Error(
       `Unexpected value for repository property '${name}' (${typeof value}), got: ${JSON.stringify(value)}`
     );
   }
 }
-function parseBooleanRepositoryProperty(name, value, logger) {
+function parseBooleanRepositoryProperty(name, value, logger2) {
   if (value !== "true" && value !== "false") {
-    logger.warning(
+    logger2.warning(
       `Repository property '${name}' has unexpected value '${value}'. Expected 'true' or 'false'. Defaulting to false.`
     );
   }
@@ -150534,14 +150580,14 @@ function parseQueriesFromInput(rawQueriesInput, queriesInputCombines, errorToThr
   }
   return trimmedInput.split(",").map((query) => ({ uses: query.trim() }));
 }
-function combineQueries(logger, config, augmentationProperties) {
+function combineQueries(logger2, config, augmentationProperties) {
   const result = [];
   if (augmentationProperties.repoPropertyQueries?.input) {
-    logger.info(
+    logger2.info(
       `Found query configuration in the repository properties (${"github-codeql-extra-queries" /* EXTRA_QUERIES */}): ${augmentationProperties.repoPropertyQueries.input.map((q) => q.uses).join(", ")}`
     );
     if (!augmentationProperties.repoPropertyQueries.combines) {
-      logger.info(
+      logger2.info(
         `The queries configured in the repository properties don't allow combining with other query settings. Any queries configured elsewhere will be ignored.`
       );
       return augmentationProperties.repoPropertyQueries.input;
@@ -150561,14 +150607,14 @@ function combineQueries(logger, config, augmentationProperties) {
   }
   return result;
 }
-function generateCodeScanningConfig(logger, originalUserInput, augmentationProperties) {
+function generateCodeScanningConfig(logger2, originalUserInput, augmentationProperties) {
   const augmentedConfig = cloneObject(originalUserInput);
   augmentedConfig.queries = combineQueries(
-    logger,
+    logger2,
     augmentedConfig,
     augmentationProperties
   );
-  logger.debug(
+  logger2.debug(
     `Combined queries: ${augmentedConfig.queries?.map((q) => q.uses).join(",")}`
   );
   if (augmentedConfig.queries?.length === 0) {
@@ -150595,7 +150641,7 @@ function generateCodeScanningConfig(logger, originalUserInput, augmentationPrope
   }
   return augmentedConfig;
 }
-function parseUserConfig(logger, pathInput, contents, validateConfig) {
+function parseUserConfig(logger2, pathInput, contents, validateConfig) {
   try {
     const schema = (
       // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -150606,7 +150652,7 @@ function parseUserConfig(logger, pathInput, contents, validateConfig) {
       const result = new jsonschema.Validator().validate(doc, schema);
       if (result.errors.length > 0) {
         for (const error3 of result.errors) {
-          logger.error(error3.stack);
+          logger2.error(error3.stack);
         }
         throw new ConfigurationError(
           getInvalidConfigFileMessage(
@@ -150630,49 +150676,6 @@ function parseUserConfig(logger, pathInput, contents, validateConfig) {
 // src/diagnostics.ts
 var import_fs = require("fs");
 var import_path = __toESM(require("path"));
-
-// src/logging.ts
-var core7 = __toESM(require_core());
-function getActionsLogger() {
-  return {
-    debug: core7.debug,
-    info: core7.info,
-    warning: core7.warning,
-    error: core7.error,
-    isDebug: core7.isDebug,
-    startGroup: core7.startGroup,
-    endGroup: core7.endGroup
-  };
-}
-function withGroup(groupName, f) {
-  core7.startGroup(groupName);
-  try {
-    return f();
-  } finally {
-    core7.endGroup();
-  }
-}
-async function withGroupAsync(groupName, f) {
-  core7.startGroup(groupName);
-  try {
-    return await f();
-  } finally {
-    core7.endGroup();
-  }
-}
-function formatDuration(durationMs) {
-  if (durationMs < 1e3) {
-    return `${durationMs}ms`;
-  }
-  if (durationMs < 60 * 1e3) {
-    return `${(durationMs / 1e3).toFixed(1)}s`;
-  }
-  const minutes = Math.floor(durationMs / (60 * 1e3));
-  const seconds = Math.floor(durationMs % (60 * 1e3) / 1e3);
-  return `${minutes}m${seconds}s`;
-}
-
-// src/diagnostics.ts
 var unwrittenDiagnostics = [];
 var unwrittenDefaultLanguageDiagnostics = [];
 var diagnosticCounter = 0;
@@ -150684,12 +150687,12 @@ function makeDiagnostic(id, name, data = void 0) {
   };
 }
 function addDiagnostic(config, language, diagnostic) {
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   const databasePath = language ? getCodeQLDatabasePath(config, language) : config.dbLocation;
   if ((0, import_fs.existsSync)(databasePath)) {
     writeDiagnostic(config, language, diagnostic);
   } else {
-    logger.debug(
+    logger2.debug(
       `Writing a diagnostic for ${language}, but the database at ${databasePath} does not exist yet.`
     );
     unwrittenDiagnostics.push({ diagnostic, language });
@@ -150709,7 +150712,7 @@ function addNoLanguageDiagnostic(config, diagnostic) {
   }
 }
 function writeDiagnostic(config, language, diagnostic) {
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   const databasePath = language ? getCodeQLDatabasePath(config, language) : config.dbLocation;
   const diagnosticsPath = import_path.default.resolve(
     databasePath,
@@ -150729,26 +150732,26 @@ function writeDiagnostic(config, language, diagnostic) {
     );
     (0, import_fs.writeFileSync)(jsonPath, JSON.stringify(diagnostic));
   } catch (err) {
-    logger.warning(`Unable to write diagnostic message to database: ${err}`);
-    logger.debug(JSON.stringify(diagnostic));
+    logger2.warning(`Unable to write diagnostic message to database: ${err}`);
+    logger2.debug(JSON.stringify(diagnostic));
   }
 }
 function logUnwrittenDiagnostics() {
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   const num = unwrittenDiagnostics.length;
   if (num > 0) {
-    logger.warning(
+    logger2.warning(
       `${num} diagnostic(s) could not be written to the database and will not appear on the Tool Status Page.`
     );
     for (const unwritten of unwrittenDiagnostics) {
-      logger.debug(JSON.stringify(unwritten.diagnostic));
+      logger2.debug(JSON.stringify(unwritten.diagnostic));
     }
   }
 }
 function flushDiagnostics(config) {
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   const diagnosticsCount = unwrittenDiagnostics.length + unwrittenDefaultLanguageDiagnostics.length;
-  logger.debug(`Writing ${diagnosticsCount} diagnostic(s) to database.`);
+  logger2.debug(`Writing ${diagnosticsCount} diagnostic(s) to database.`);
   for (const unwritten of unwrittenDiagnostics) {
     writeDiagnostic(config, unwritten.language, unwritten.diagnostic);
   }
@@ -150771,7 +150774,7 @@ function makeTelemetryDiagnostic(id, name, attributes) {
 
 // src/diff-informed-analysis-utils.ts
 var fs7 = __toESM(require("fs"));
-async function getDiffInformedAnalysisBranches(codeql, features, logger) {
+async function getDiffInformedAnalysisBranches(codeql, features, logger2) {
   if (!await features.getValue("diff_informed_queries" /* DiffInformedQueries */, codeql)) {
     return void 0;
   }
@@ -150781,18 +150784,18 @@ async function getDiffInformedAnalysisBranches(codeql, features, logger) {
   }
   const branches = getPullRequestBranches();
   if (!branches) {
-    logger.info(
+    logger2.info(
       "Not performing diff-informed analysis because we are not analyzing a pull request."
     );
   }
   return branches;
 }
-async function prepareDiffInformedAnalysis(codeql, features, logger) {
+async function prepareDiffInformedAnalysis(codeql, features, logger2) {
   let branches;
   try {
-    branches = await getDiffInformedAnalysisBranches(codeql, features, logger);
+    branches = await getDiffInformedAnalysisBranches(codeql, features, logger2);
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to determine branch information for diff-informed analysis: ${getErrorMessage(e)}`
     );
     return false;
@@ -150801,57 +150804,57 @@ async function prepareDiffInformedAnalysis(codeql, features, logger) {
     return false;
   }
   try {
-    return await computeAndPersistDiffRanges(branches, logger);
+    return await computeAndPersistDiffRanges(branches, logger2);
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to compute diff-informed analysis ranges: ${getErrorMessage(e)}`
     );
     return false;
   }
 }
-function writeDiffRangesJsonFile(logger, ranges) {
+function writeDiffRangesJsonFile(logger2, ranges) {
   const jsonContents = JSON.stringify(ranges, null, 2);
   const jsonFilePath = getDiffRangesJsonFilePath();
   fs7.writeFileSync(jsonFilePath, jsonContents);
-  logger.debug(
+  logger2.debug(
     `Wrote pr-diff-range JSON file to ${jsonFilePath}:
 ${jsonContents}`
   );
 }
-function readDiffRangesJsonFile(logger) {
+function readDiffRangesJsonFile(logger2) {
   const jsonFilePath = getDiffRangesJsonFilePath();
   if (!fs7.existsSync(jsonFilePath)) {
-    logger.debug(`Diff ranges JSON file does not exist at ${jsonFilePath}`);
+    logger2.debug(`Diff ranges JSON file does not exist at ${jsonFilePath}`);
     return void 0;
   }
   const jsonContents = fs7.readFileSync(jsonFilePath, "utf8");
-  logger.debug(
+  logger2.debug(
     `Read pr-diff-range JSON file from ${jsonFilePath}:
 ${jsonContents}`
   );
   try {
     return JSON.parse(jsonContents);
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to parse diff ranges JSON file at ${jsonFilePath}: ${e}`
     );
     return void 0;
   }
 }
-async function getPullRequestEditedDiffRanges(branches, logger) {
-  const fileDiffs = await getFileDiffsWithBasehead(branches, logger);
+async function getPullRequestEditedDiffRanges(branches, logger2) {
+  const fileDiffs = await getFileDiffsWithBasehead(branches, logger2);
   if (fileDiffs === void 0) {
     return void 0;
   }
   if (fileDiffs.length >= 300) {
-    logger.warning(
+    logger2.warning(
       `Cannot retrieve the full diff because there are too many (${fileDiffs.length}) changed files in the pull request.`
     );
     return void 0;
   }
   const results = [];
   for (const filediff of fileDiffs) {
-    const diffRanges = getDiffRanges(filediff, logger);
+    const diffRanges = getDiffRanges(filediff, logger2);
     if (diffRanges === void 0) {
       return void 0;
     }
@@ -150859,20 +150862,20 @@ async function getPullRequestEditedDiffRanges(branches, logger) {
   }
   return results;
 }
-async function computeAndPersistDiffRanges(branches, logger) {
-  logger.info("Computing PR diff ranges...");
-  const ranges = await getPullRequestEditedDiffRanges(branches, logger);
+async function computeAndPersistDiffRanges(branches, logger2) {
+  logger2.info("Computing PR diff ranges...");
+  const ranges = await getPullRequestEditedDiffRanges(branches, logger2);
   if (ranges === void 0) {
     return false;
   }
-  writeDiffRangesJsonFile(logger, ranges);
+  writeDiffRangesJsonFile(logger2, ranges);
   const distinctFiles = new Set(ranges.map((r) => r.path)).size;
-  logger.info(
+  logger2.info(
     `Persisted ${ranges.length} diff range(s) across ${distinctFiles} file(s).`
   );
   return true;
 }
-async function getFileDiffsWithBasehead(branches, logger) {
+async function getFileDiffsWithBasehead(branches, logger2) {
   const repositoryNwo = getRepositoryNwoFromEnv(
     "CODE_SCANNING_REPOSITORY",
     "GITHUB_REPOSITORY"
@@ -150887,15 +150890,15 @@ async function getFileDiffsWithBasehead(branches, logger) {
         per_page: 1
       }
     );
-    logger.debug(
+    logger2.debug(
       `Response from compareCommitsWithBasehead(${basehead}):
 ${JSON.stringify(response, null, 2)}`
     );
     return response.data.files;
   } catch (error3) {
     if (error3.status) {
-      logger.warning(`Error retrieving diff ${basehead}: ${error3.message}`);
-      logger.debug(
+      logger2.warning(`Error retrieving diff ${basehead}: ${error3.message}`);
+      logger2.debug(
         `Error running compareCommitsWithBasehead(${basehead}):
 Request: ${JSON.stringify(error3.request, null, 2)}
 Error Response: ${JSON.stringify(error3.response, null, 2)}`
@@ -150906,7 +150909,7 @@ Error Response: ${JSON.stringify(error3.response, null, 2)}`
     }
   }
 }
-function getDiffRanges(fileDiff, logger) {
+function getDiffRanges(fileDiff, logger2) {
   if (fileDiff.patch === void 0) {
     if (fileDiff.changes === 0) {
       return [];
@@ -150946,7 +150949,7 @@ function getDiffRanges(fileDiff, logger) {
     if (diffLine.startsWith("@@ ")) {
       const match = diffLine.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
       if (match === null) {
-        logger.warning(
+        logger2.warning(
           `Cannot parse diff hunk header for ${fileDiff.filename}: ${diffLine}`
         );
         return void 0;
@@ -151100,23 +151103,23 @@ function createOverlayStatus(attributes, checkRunId) {
     job
   };
 }
-async function shouldSkipOverlayAnalysis(codeql, languages, diskUsage, logger) {
-  const status = await getOverlayStatus(codeql, languages, diskUsage, logger);
+async function shouldSkipOverlayAnalysis(codeql, languages, diskUsage, logger2) {
+  const status = await getOverlayStatus(codeql, languages, diskUsage, logger2);
   if (status === void 0) {
     return false;
   }
   if (status.attemptedToBuildOverlayBaseDatabase && !status.builtOverlayBaseDatabase) {
-    logger.debug(
+    logger2.debug(
       "Cached overlay status indicates that building an overlay base database was unsuccessful."
     );
     return true;
   }
-  logger.debug(
+  logger2.debug(
     "Cached overlay status does not indicate a previous unsuccessful attempt to build an overlay base database."
   );
   return false;
 }
-async function getOverlayStatus(codeql, languages, diskUsage, logger) {
+async function getOverlayStatus(codeql, languages, diskUsage, logger2) {
   const cacheKey3 = await getCacheKey(codeql, languages, diskUsage);
   const statusFile = getStatusFilePath(languages);
   try {
@@ -151125,15 +151128,15 @@ async function getOverlayStatus(codeql, languages, diskUsage, logger) {
       MAX_CACHE_OPERATION_MS,
       actionsCache.restoreCache([statusFile], cacheKey3),
       () => {
-        logger.warning("Timed out restoring overlay status from cache.");
+        logger2.warning("Timed out restoring overlay status from cache.");
       }
     );
     if (foundKey === void 0) {
-      logger.debug("No overlay status found in Actions cache.");
+      logger2.debug("No overlay status found in Actions cache.");
       return void 0;
     }
     if (!fs8.existsSync(statusFile)) {
-      logger.debug(
+      logger2.debug(
         "Overlay status cache entry found but status file is missing."
       );
       return void 0;
@@ -151141,20 +151144,20 @@ async function getOverlayStatus(codeql, languages, diskUsage, logger) {
     const contents = await fs8.promises.readFile(statusFile, "utf-8");
     const parsed = JSON.parse(contents);
     if (!isObject(parsed) || typeof parsed["attemptedToBuildOverlayBaseDatabase"] !== "boolean" || typeof parsed["builtOverlayBaseDatabase"] !== "boolean") {
-      logger.debug(
+      logger2.debug(
         "Ignoring overlay status cache entry with unexpected format."
       );
       return void 0;
     }
     return parsed;
   } catch (error3) {
-    logger.warning(
+    logger2.warning(
       `Failed to restore overlay status from cache: ${getErrorMessage(error3)}`
     );
     return void 0;
   }
 }
-async function saveOverlayStatus(codeql, languages, diskUsage, status, logger) {
+async function saveOverlayStatus(codeql, languages, diskUsage, status, logger2) {
   const cacheKey3 = await getCacheKey(codeql, languages, diskUsage);
   const statusFile = getStatusFilePath(languages);
   try {
@@ -151164,16 +151167,16 @@ async function saveOverlayStatus(codeql, languages, diskUsage, status, logger) {
       MAX_CACHE_OPERATION_MS,
       actionsCache.saveCache([statusFile], cacheKey3),
       () => {
-        logger.warning("Timed out saving overlay status to cache.");
+        logger2.warning("Timed out saving overlay status to cache.");
       }
     );
     if (cacheId === void 0) {
       return false;
     }
-    logger.debug(`Saved overlay status to Actions cache with key ${cacheKey3}`);
+    logger2.debug(`Saved overlay status to Actions cache with key ${cacheKey3}`);
     return true;
   } catch (error3) {
-    logger.warning(
+    logger2.warning(
       `Failed to save overlay status to cache: ${getErrorMessage(error3)}`
     );
     return false;
@@ -151192,14 +151195,14 @@ var CACHE_VERSION = 1;
 var CODEQL_TRAP_CACHE_PREFIX = "codeql-trap";
 var MINIMUM_CACHE_MB_TO_UPLOAD = 10;
 var MAX_CACHE_OPERATION_MS2 = 12e4;
-async function downloadTrapCaches(codeql, languages, logger) {
+async function downloadTrapCaches(codeql, languages, logger2) {
   const result = {};
   const languagesSupportingCaching = await getLanguagesSupportingCaching(
     codeql,
     languages,
-    logger
+    logger2
   );
-  logger.info(
+  logger2.info(
     `Found ${languagesSupportingCaching.length} languages that support TRAP caching`
   );
   if (languagesSupportingCaching.length === 0) return result;
@@ -151213,7 +151216,7 @@ async function downloadTrapCaches(codeql, languages, logger) {
     result[language] = cacheDir2;
   }
   if (await isAnalyzingDefaultBranch()) {
-    logger.info(
+    logger2.info(
       "Analyzing default branch. Skipping downloading of TRAP caches."
     );
     return result;
@@ -151228,7 +151231,7 @@ async function downloadTrapCaches(codeql, languages, logger) {
     const cacheDir2 = result[language];
     if (cacheDir2 === void 0) continue;
     const preferredKey = await cacheKey(codeql, language, baseSha);
-    logger.info(
+    logger2.info(
       `Looking in Actions cache for TRAP cache with key ${preferredKey}`
     );
     const found = await waitForResultWithTimeLimit(
@@ -151238,32 +151241,32 @@ async function downloadTrapCaches(codeql, languages, logger) {
         await cachePrefix(codeql, language)
       ]),
       () => {
-        logger.info(
+        logger2.info(
           `Timed out downloading cache for ${language}, will continue without it`
         );
       }
     );
     if (found === void 0) {
-      logger.info(`No TRAP cache found in Actions cache for ${language}`);
+      logger2.info(`No TRAP cache found in Actions cache for ${language}`);
       delete result[language];
     }
   }
   return result;
 }
-async function uploadTrapCaches(codeql, config, logger) {
+async function uploadTrapCaches(codeql, config, logger2) {
   if (!await isAnalyzingDefaultBranch()) return false;
   for (const language of config.languages) {
     const cacheDir2 = config.trapCaches[language];
     if (cacheDir2 === void 0) continue;
-    const trapFolderSize = await tryGetFolderBytes(cacheDir2, logger);
+    const trapFolderSize = await tryGetFolderBytes(cacheDir2, logger2);
     if (trapFolderSize === void 0) {
-      logger.info(
+      logger2.info(
         `Skipping upload of TRAP cache for ${language} as we couldn't determine its size`
       );
       continue;
     }
     if (trapFolderSize < MINIMUM_CACHE_MB_TO_UPLOAD * 1048576) {
-      logger.info(
+      logger2.info(
         `Skipping upload of TRAP cache for ${language} as it is too small`
       );
       continue;
@@ -151273,12 +151276,12 @@ async function uploadTrapCaches(codeql, config, logger) {
       language,
       process.env.GITHUB_SHA || "unknown"
     );
-    logger.info(`Uploading TRAP cache to Actions cache with key ${key}`);
+    logger2.info(`Uploading TRAP cache to Actions cache with key ${key}`);
     await waitForResultWithTimeLimit(
       MAX_CACHE_OPERATION_MS2,
       actionsCache2.saveCache([cacheDir2], key),
       () => {
-        logger.info(
+        logger2.info(
           `Timed out waiting for TRAP cache for ${language} to upload, will continue without uploading`
         );
       }
@@ -151286,13 +151289,13 @@ async function uploadTrapCaches(codeql, config, logger) {
   }
   return true;
 }
-async function cleanupTrapCaches(config, features, logger) {
+async function cleanupTrapCaches(config, features, logger2) {
   if (!await features.getValue("cleanup_trap_caches" /* CleanupTrapCaches */)) {
     return {
       trap_cache_cleanup_skipped_because: "feature disabled"
     };
   }
-  logger.warning(
+  logger2.warning(
     "TRAP cache cleanup is deprecated and will be removed in May 2026. We recommend instead disabling TRAP caching by passing the `trap-caching: false` input to the `init` Action."
   );
   if (!await isAnalyzingDefaultBranch()) {
@@ -151311,19 +151314,19 @@ async function cleanupTrapCaches(config, features, logger) {
         const cachesToRemove = await getTrapCachesForLanguage(
           allCaches,
           language,
-          logger
+          logger2
         );
         cachesToRemove.sort((a, b) => a.created_at.localeCompare(b.created_at));
         const mostRecentCache = cachesToRemove.pop();
-        logger.debug(
+        logger2.debug(
           `Keeping most recent TRAP cache (${JSON.stringify(mostRecentCache)})`
         );
         if (cachesToRemove.length === 0) {
-          logger.info(`No TRAP caches to clean up for ${language}.`);
+          logger2.info(`No TRAP caches to clean up for ${language}.`);
           continue;
         }
         for (const cache of cachesToRemove) {
-          logger.debug(`Cleaning up TRAP cache (${JSON.stringify(cache)})`);
+          logger2.debug(`Cleaning up TRAP cache (${JSON.stringify(cache)})`);
           await deleteActionsCache(cache.id);
         }
         const bytesCleanedUp = cachesToRemove.reduce(
@@ -151332,7 +151335,7 @@ async function cleanupTrapCaches(config, features, logger) {
         );
         totalBytesCleanedUp += bytesCleanedUp;
         const megabytesCleanedUp = (bytesCleanedUp / (1024 * 1024)).toFixed(2);
-        logger.info(
+        logger2.info(
           `Cleaned up ${megabytesCleanedUp} MiB of old TRAP caches for ${language}.`
         );
       }
@@ -151340,17 +151343,17 @@ async function cleanupTrapCaches(config, features, logger) {
     return { trap_cache_cleanup_size_bytes: totalBytesCleanedUp };
   } catch (e) {
     if (asHTTPError(e)?.status === 403) {
-      logger.warning(
+      logger2.warning(
         `Could not cleanup TRAP caches as the token did not have the required permissions. To clean up TRAP caches, ensure the token has the "actions:write" permission. See ${"https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs" /* ASSIGNING_PERMISSIONS_TO_JOBS */} for more information.`
       );
     } else {
-      logger.info(`Failed to cleanup TRAP caches, continuing. Details: ${e}`);
+      logger2.info(`Failed to cleanup TRAP caches, continuing. Details: ${e}`);
     }
     return { trap_cache_cleanup_error: getErrorMessage(e) };
   }
 }
-async function getTrapCachesForLanguage(allCaches, language, logger) {
-  logger.debug(`Listing TRAP caches for ${language}`);
+async function getTrapCachesForLanguage(allCaches, language, logger2) {
+  logger2.debug(`Listing TRAP caches for ${language}`);
   for (const cache of allCaches) {
     if (!cache.created_at || !cache.id || !cache.key || !cache.size_in_bytes) {
       throw new Error(
@@ -151362,19 +151365,19 @@ async function getTrapCachesForLanguage(allCaches, language, logger) {
     return cache.key?.includes(`-${language}-`);
   });
 }
-async function getLanguagesSupportingCaching(codeql, languages, logger) {
+async function getLanguagesSupportingCaching(codeql, languages, logger2) {
   const result = [];
   const resolveResult = await codeql.resolveLanguages();
   outer: for (const lang of languages) {
     const extractorsForLanguage = resolveResult.extractors[lang];
     if (extractorsForLanguage === void 0) {
-      logger.info(
+      logger2.info(
         `${lang} does not support TRAP caching (couldn't find an extractor)`
       );
       continue;
     }
     if (extractorsForLanguage.length !== 1) {
-      logger.info(
+      logger2.info(
         `${lang} does not support TRAP caching (found multiple extractors)`
       );
       continue;
@@ -151382,14 +151385,14 @@ async function getLanguagesSupportingCaching(codeql, languages, logger) {
     const extractor = extractorsForLanguage[0];
     const trapCacheOptions = extractor.extractor_options?.trap?.properties?.cache?.properties;
     if (trapCacheOptions === void 0) {
-      logger.info(
+      logger2.info(
         `${lang} does not support TRAP caching (missing option group)`
       );
       continue;
     }
     for (const requiredOpt of ["dir", "bound", "write"]) {
       if (!(requiredOpt in trapCacheOptions)) {
-        logger.info(
+        logger2.info(
           `${lang} does not support TRAP caching (missing ${requiredOpt} option)`
         );
         continue outer;
@@ -151413,13 +151416,13 @@ var OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_V2_MB = 14e3;
 var OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_V2_BYTES = OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_V2_MB * 1e6;
 var OVERLAY_MINIMUM_MEMORY_MB = 5 * 1024;
 var CODEQL_VERSION_REDUCED_OVERLAY_MEMORY_USAGE = "2.24.3";
-async function getSupportedLanguageMap(codeql, logger) {
+async function getSupportedLanguageMap(codeql, logger2) {
   const resolveSupportedLanguagesUsingCli = await codeql.supportsFeature(
     "builtinExtractorsSpecifyDefaultQueries" /* BuiltinExtractorsSpecifyDefaultQueries */
   );
   const resolveResult = await codeql.resolveLanguages();
   if (resolveSupportedLanguagesUsingCli) {
-    logger.debug(
+    logger2.debug(
       `The CodeQL CLI supports the following languages: ${Object.keys(resolveResult.extractors).join(", ")}`
     );
   }
@@ -151442,33 +151445,33 @@ function hasActionsWorkflows(sourceRoot) {
   const stats = fs10.lstatSync(workflowsPath, { throwIfNoEntry: false });
   return stats !== void 0 && stats.isDirectory() && fs10.readdirSync(workflowsPath).length > 0;
 }
-async function getRawLanguagesInRepo(repository, sourceRoot, logger) {
-  logger.debug(
+async function getRawLanguagesInRepo(repository, sourceRoot, logger2) {
+  logger2.debug(
     `Automatically detecting languages (${repository.owner}/${repository.repo})`
   );
   const response = await getApiClient().rest.repos.listLanguages({
     owner: repository.owner,
     repo: repository.repo
   });
-  logger.debug(`Languages API response: ${JSON.stringify(response)}`);
+  logger2.debug(`Languages API response: ${JSON.stringify(response)}`);
   const result = Object.keys(response.data).map(
     (language) => language.trim().toLowerCase()
   );
   if (hasActionsWorkflows(sourceRoot)) {
-    logger.debug(`Found a .github/workflows directory`);
+    logger2.debug(`Found a .github/workflows directory`);
     result.push("actions");
   }
-  logger.debug(`Raw languages in repository: ${result.join(", ")}`);
+  logger2.debug(`Raw languages in repository: ${result.join(", ")}`);
   return result;
 }
-async function getLanguages(codeql, languagesInput, repository, sourceRoot, logger) {
+async function getLanguages(codeql, languagesInput, repository, sourceRoot, logger2) {
   const { rawLanguages, autodetected } = await getRawLanguages(
     languagesInput,
     repository,
     sourceRoot,
-    logger
+    logger2
   );
-  const languageMap = await getSupportedLanguageMap(codeql, logger);
+  const languageMap = await getSupportedLanguageMap(codeql, logger2);
   const languagesSet = /* @__PURE__ */ new Set();
   const unknownLanguages = [];
   for (const language of rawLanguages) {
@@ -151489,22 +151492,22 @@ async function getLanguages(codeql, languagesInput, repository, sourceRoot, logg
     throw new ConfigurationError(getNoLanguagesError());
   }
   if (autodetected) {
-    logger.info(`Autodetected languages: ${languages.join(", ")}`);
+    logger2.info(`Autodetected languages: ${languages.join(", ")}`);
   } else {
-    logger.info(`Languages from configuration: ${languages.join(", ")}`);
+    logger2.info(`Languages from configuration: ${languages.join(", ")}`);
   }
   return languages;
 }
 function getRawLanguagesNoAutodetect(languagesInput) {
   return (languagesInput || "").split(",").map((x) => x.trim().toLowerCase()).filter((x) => x.length > 0);
 }
-async function getRawLanguages(languagesInput, repository, sourceRoot, logger) {
+async function getRawLanguages(languagesInput, repository, sourceRoot, logger2) {
   const languagesFromInput = getRawLanguagesNoAutodetect(languagesInput);
   if (languagesFromInput.length > 0) {
     return { rawLanguages: languagesFromInput, autodetected: false };
   }
   return {
-    rawLanguages: await getRawLanguagesInRepo(repository, sourceRoot, logger),
+    rawLanguages: await getRawLanguagesInRepo(repository, sourceRoot, logger2),
     autodetected: true
   };
 }
@@ -151526,7 +151529,7 @@ async function initActionState({
   features,
   repositoryProperties,
   analysisKinds,
-  logger,
+  logger: logger2,
   enableFileCoverageInformation
 }, userConfig) {
   const languages = await getLanguages(
@@ -151534,13 +151537,13 @@ async function initActionState({
     languagesInput,
     repository,
     sourceRoot,
-    logger
+    logger2
   );
   const buildMode = await parseBuildModeInput(
     buildModeInput,
     languages,
     features,
-    logger
+    logger2
   );
   const augmentationProperties = await calculateAugmentation(
     packsInput,
@@ -151549,7 +151552,7 @@ async function initActionState({
     languages
   );
   if (analysisKinds.length === 1 && analysisKinds.includes("code-quality" /* CodeQuality */) && augmentationProperties.repoPropertyQueries.input) {
-    logger.info(
+    logger2.info(
       `Ignoring queries configured in the repository properties, because query customisations are not supported for Code Quality analyses.`
     );
     augmentationProperties.repoPropertyQueries = {
@@ -151558,7 +151561,7 @@ async function initActionState({
     };
   }
   const computedConfig = generateCodeScanningConfig(
-    logger,
+    logger2,
     userConfig,
     augmentationProperties
   );
@@ -151588,13 +151591,13 @@ async function initActionState({
     enableFileCoverageInformation
   };
 }
-async function downloadCacheWithTime(codeQL, languages, logger) {
+async function downloadCacheWithTime(codeQL, languages, logger2) {
   const start = import_perf_hooks.performance.now();
-  const trapCaches = await downloadTrapCaches(codeQL, languages, logger);
+  const trapCaches = await downloadTrapCaches(codeQL, languages, logger2);
   const trapCacheDownloadTime = import_perf_hooks.performance.now() - start;
   return { trapCaches, trapCacheDownloadTime };
 }
-async function loadUserConfig(logger, configFile, workspacePath, apiDetails, tempDir, validateConfig) {
+async function loadUserConfig(logger2, configFile, workspacePath, apiDetails, tempDir, validateConfig) {
   if (isLocal(configFile)) {
     if (configFile !== userConfigFromActionPath(tempDir)) {
       configFile = path11.resolve(workspacePath, configFile);
@@ -151604,10 +151607,10 @@ async function loadUserConfig(logger, configFile, workspacePath, apiDetails, tem
         );
       }
     }
-    return getLocalConfig(logger, configFile, validateConfig);
+    return getLocalConfig(logger2, configFile, validateConfig);
   } else {
     return await getRemoteConfig(
-      logger,
+      logger2,
       configFile,
       apiDetails,
       validateConfig
@@ -151657,53 +151660,53 @@ async function checkOverlayAnalysisFeatureEnabled(features, codeql, languages, c
   }
   return new Success(void 0);
 }
-function runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks) {
+function runnerHasSufficientDiskSpace(diskUsage, logger2, useV2ResourceChecks) {
   const minimumDiskSpaceBytes = useV2ResourceChecks ? OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_V2_BYTES : OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_BYTES;
   if (diskUsage.numAvailableBytes < minimumDiskSpaceBytes) {
     const diskSpaceMb = Math.round(diskUsage.numAvailableBytes / 1e6);
     const minimumDiskSpaceMb = Math.round(minimumDiskSpaceBytes / 1e6);
-    logger.info(
+    logger2.info(
       `Setting overlay database mode to ${"none" /* None */} due to insufficient disk space (${diskSpaceMb} MB, needed ${minimumDiskSpaceMb} MB).`
     );
     return false;
   }
   return true;
 }
-async function runnerHasSufficientMemory(codeql, ramInput, logger) {
+async function runnerHasSufficientMemory(codeql, ramInput, logger2) {
   if (await codeQlVersionAtLeast(
     codeql,
     CODEQL_VERSION_REDUCED_OVERLAY_MEMORY_USAGE
   )) {
-    logger.debug(
+    logger2.debug(
       `Skipping memory check for overlay analysis because CodeQL version is at least ${CODEQL_VERSION_REDUCED_OVERLAY_MEMORY_USAGE}.`
     );
     return true;
   }
-  const memoryFlagValue = getCodeQLMemoryLimit(ramInput, logger);
+  const memoryFlagValue = getCodeQLMemoryLimit(ramInput, logger2);
   if (memoryFlagValue < OVERLAY_MINIMUM_MEMORY_MB) {
-    logger.info(
+    logger2.info(
       `Setting overlay database mode to ${"none" /* None */} due to insufficient memory for CodeQL analysis (${memoryFlagValue} MB, needed ${OVERLAY_MINIMUM_MEMORY_MB} MB).`
     );
     return false;
   }
-  logger.debug(
+  logger2.debug(
     `Memory available for CodeQL analysis is ${memoryFlagValue} MB, which is above the minimum of ${OVERLAY_MINIMUM_MEMORY_MB} MB.`
   );
   return true;
 }
-async function checkRunnerResources(codeql, diskUsage, ramInput, logger, useV2ResourceChecks) {
-  if (!runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks)) {
+async function checkRunnerResources(codeql, diskUsage, ramInput, logger2, useV2ResourceChecks) {
+  if (!runnerHasSufficientDiskSpace(diskUsage, logger2, useV2ResourceChecks)) {
     return new Failure("insufficient-disk-space" /* InsufficientDiskSpace */);
   }
-  if (!await runnerHasSufficientMemory(codeql, ramInput, logger)) {
+  if (!await runnerHasSufficientMemory(codeql, ramInput, logger2)) {
     return new Failure("insufficient-memory" /* InsufficientMemory */);
   }
   return new Success(void 0);
 }
-async function checkOverlayEnablement(codeql, features, languages, sourceRoot, buildMode, ramInput, codeScanningConfig, repositoryProperties, gitVersion, logger) {
+async function checkOverlayEnablement(codeql, features, languages, sourceRoot, buildMode, ramInput, codeScanningConfig, repositoryProperties, gitVersion, logger2) {
   const modeEnv = process.env.CODEQL_OVERLAY_DATABASE_MODE;
   if (modeEnv === "overlay" /* Overlay */ || modeEnv === "overlay-base" /* OverlayBase */ || modeEnv === "none" /* None */) {
-    logger.info(
+    logger2.info(
       `Setting overlay database mode to ${modeEnv} from the CODEQL_OVERLAY_DATABASE_MODE environment variable.`
     );
     if (modeEnv === "none" /* None */) {
@@ -151718,11 +151721,11 @@ async function checkOverlayEnablement(codeql, features, languages, sourceRoot, b
       sourceRoot,
       buildMode,
       gitVersion,
-      logger
+      logger2
     );
   }
   if (repositoryProperties["github-codeql-disable-overlay" /* DISABLE_OVERLAY */] === true) {
-    logger.info(
+    logger2.info(
       `Setting overlay database mode to ${"none" /* None */} because the ${"github-codeql-disable-overlay" /* DISABLE_OVERLAY */} repository property is set to true.`
     );
     return new Failure("disabled-by-repository-property" /* DisabledByRepositoryProperty */);
@@ -151747,9 +151750,9 @@ async function checkOverlayEnablement(codeql, features, languages, sourceRoot, b
     "overlay_analysis_status_check" /* OverlayAnalysisStatusCheck */
   );
   const needDiskUsage = performResourceChecks || checkOverlayStatus;
-  const diskUsage = needDiskUsage ? await checkDiskUsage(logger) : void 0;
+  const diskUsage = needDiskUsage ? await checkDiskUsage(logger2) : void 0;
   if (needDiskUsage && diskUsage === void 0) {
-    logger.warning(
+    logger2.warning(
       `Unable to determine disk usage, therefore setting overlay database mode to ${"none" /* None */}.`
     );
     return new Failure("unable-to-determine-disk-usage" /* UnableToDetermineDiskUsage */);
@@ -151758,14 +151761,14 @@ async function checkOverlayEnablement(codeql, features, languages, sourceRoot, b
     codeql,
     diskUsage,
     ramInput,
-    logger,
+    logger2,
     useV2ResourceChecks
   ) : new Success(void 0);
   if (resourceResult.isFailure()) {
     return resourceResult;
   }
-  if (checkOverlayStatus && diskUsage !== void 0 && await shouldSkipOverlayAnalysis(codeql, languages, diskUsage, logger)) {
-    logger.info(
+  if (checkOverlayStatus && diskUsage !== void 0 && await shouldSkipOverlayAnalysis(codeql, languages, diskUsage, logger2)) {
+    logger2.info(
       `Setting overlay database mode to ${"none" /* None */} because overlay analysis previously failed with this combination of languages, disk space, and CodeQL version.`
     );
     return new Failure("skipped-due-to-cached-status" /* SkippedDueToCachedStatus */);
@@ -151773,12 +151776,12 @@ async function checkOverlayEnablement(codeql, features, languages, sourceRoot, b
   let overlayDatabaseMode;
   if (isAnalyzingPullRequest()) {
     overlayDatabaseMode = "overlay" /* Overlay */;
-    logger.info(
+    logger2.info(
       `Setting overlay database mode to ${overlayDatabaseMode} with caching because we are analyzing a pull request.`
     );
   } else if (await isAnalyzingDefaultBranch()) {
     overlayDatabaseMode = "overlay-base" /* OverlayBase */;
-    logger.info(
+    logger2.info(
       `Setting overlay database mode to ${overlayDatabaseMode} with caching because we are analyzing the default branch.`
     );
   } else {
@@ -151793,10 +151796,10 @@ async function checkOverlayEnablement(codeql, features, languages, sourceRoot, b
     sourceRoot,
     buildMode,
     gitVersion,
-    logger
+    logger2
   );
 }
-async function validateOverlayDatabaseMode(overlayDatabaseMode, useOverlayDatabaseCaching, overlayModeSetExplicitly, codeql, languages, sourceRoot, buildMode, gitVersion, logger) {
+async function validateOverlayDatabaseMode(overlayDatabaseMode, useOverlayDatabaseCaching, overlayModeSetExplicitly, codeql, languages, sourceRoot, buildMode, gitVersion, logger2) {
   if (buildMode !== "none" /* None */ && (await Promise.all(
     languages.map(
       async (l) => l !== "go" /* go */ && // Workaround to allow overlay analysis for Go with any build
@@ -151806,33 +151809,33 @@ async function validateOverlayDatabaseMode(overlayDatabaseMode, useOverlayDataba
       await codeql.isTracedLanguage(l)
     )
   )).some(Boolean)) {
-    logger.warning(
+    logger2.warning(
       `Cannot build an ${overlayDatabaseMode} database because build-mode is set to "${buildMode}" instead of "none". Falling back to creating a normal full database instead.`
     );
     return new Failure("incompatible-build-mode" /* IncompatibleBuildMode */);
   }
   if (!await codeQlVersionAtLeast(codeql, CODEQL_OVERLAY_MINIMUM_VERSION)) {
-    logger.warning(
+    logger2.warning(
       `Cannot build an ${overlayDatabaseMode} database because the CodeQL CLI is older than ${CODEQL_OVERLAY_MINIMUM_VERSION}. Falling back to creating a normal full database instead.`
     );
     return new Failure("incompatible-codeql" /* IncompatibleCodeQl */);
   }
   const gitRoot = await getGitRoot(sourceRoot);
   if (gitRoot === void 0) {
-    logger.warning(
+    logger2.warning(
       `Cannot build an ${overlayDatabaseMode} database because the source root "${sourceRoot}" is not inside a git repository. Falling back to creating a normal full database instead.`
     );
     return new Failure("no-git-root" /* NoGitRoot */);
   }
   if (hasSubmodules(gitRoot)) {
     if (gitVersion === void 0) {
-      logger.warning(
+      logger2.warning(
         `Cannot build an ${overlayDatabaseMode} database because the repository has submodules and the Git version could not be determined. Falling back to creating a normal full database instead.`
       );
       return new Failure("incompatible-git" /* IncompatibleGit */);
     }
     if (!gitVersion.isAtLeast(GIT_MINIMUM_VERSION_FOR_OVERLAY_WITH_SUBMODULES)) {
-      logger.warning(
+      logger2.warning(
         `Cannot build an ${overlayDatabaseMode} database because the repository has submodules and the installed Git version is older than ${GIT_MINIMUM_VERSION_FOR_OVERLAY_WITH_SUBMODULES}. Falling back to creating a normal full database instead.`
       );
       return new Failure("incompatible-git" /* IncompatibleGit */);
@@ -151853,18 +151856,18 @@ async function isTrapCachingEnabled(features, overlayDatabaseMode) {
   }
   return true;
 }
-async function setCppTrapCachingEnvironmentVariables(config, logger) {
+async function setCppTrapCachingEnvironmentVariables(config, logger2) {
   if (config.languages.includes("cpp" /* cpp */)) {
     const envVar = "CODEQL_EXTRACTOR_CPP_TRAP_CACHING";
     if (process.env[envVar]) {
-      logger.info(
+      logger2.info(
         `Environment variable ${envVar} already set, leaving it unchanged.`
       );
     } else if (config.trapCaches["cpp" /* cpp */]) {
-      logger.info("Enabling TRAP caching for C/C++.");
+      logger2.info("Enabling TRAP caching for C/C++.");
       core8.exportVariable(envVar, "true");
     } else {
-      logger.debug(`Disabling TRAP caching for C/C++.`);
+      logger2.debug(`Disabling TRAP caching for C/C++.`);
       core8.exportVariable(envVar, "false");
     }
   }
@@ -151878,9 +151881,9 @@ function userConfigFromActionPath(tempDir) {
 function hasQueryCustomisation(userConfig) {
   return isDefined2(userConfig["disable-default-queries"]) || isDefined2(userConfig.queries) || isDefined2(userConfig["query-filters"]);
 }
-async function applyIncrementalAnalysisSettings(config, hasDiffRanges, codeql, logger) {
+async function applyIncrementalAnalysisSettings(config, hasDiffRanges, codeql, logger2) {
   if (config.overlayDatabaseMode === "overlay" /* Overlay */ && !hasDiffRanges && !config.overlayModeSetExplicitly) {
-    logger.info(
+    logger2.info(
       `Reverting overlay database mode to ${"none" /* None */} because the PR diff ranges could not be computed.`
     );
     config.overlayDatabaseMode = "none" /* None */;
@@ -151898,25 +151901,25 @@ async function applyIncrementalAnalysisSettings(config, hasDiffRanges, codeql, l
   }
 }
 async function initConfig(features, inputs) {
-  const { logger, tempDir } = inputs;
+  const { logger: logger2, tempDir } = inputs;
   if (inputs.configInput) {
     if (inputs.configFile) {
-      logger.warning(
+      logger2.warning(
         `Both a config file and config input were provided. Ignoring config file.`
       );
     }
     inputs.configFile = userConfigFromActionPath(tempDir);
     fs10.writeFileSync(inputs.configFile, inputs.configInput);
-    logger.debug(`Using config from action input: ${inputs.configFile}`);
+    logger2.debug(`Using config from action input: ${inputs.configFile}`);
   }
   let userConfig = {};
   if (!inputs.configFile) {
-    logger.debug("No configuration file was provided");
+    logger2.debug("No configuration file was provided");
   } else {
-    logger.debug(`Using configuration file: ${inputs.configFile}`);
+    logger2.debug(`Using configuration file: ${inputs.configFile}`);
     const validateConfig = await features.getValue("validate_db_config" /* ValidateDbConfig */);
     userConfig = await loadUserConfig(
-      logger,
+      logger2,
       inputs.configFile,
       inputs.workspacePath,
       inputs.apiDetails,
@@ -151939,10 +151942,10 @@ async function initConfig(features, inputs) {
   let gitVersion = void 0;
   try {
     gitVersion = await getGitVersionOrThrow();
-    logger.info(`Using Git version ${gitVersion.fullVersion}`);
+    logger2.info(`Using Git version ${gitVersion.fullVersion}`);
     await logGitVersionTelemetry(config, gitVersion);
   } catch (e) {
-    logger.warning(`Could not determine Git version: ${getErrorMessage(e)}`);
+    logger2.warning(`Could not determine Git version: ${getErrorMessage(e)}`);
     if (isInTestMode() && process.env["CODEQL_ACTION_TOLERATE_MISSING_GIT_VERSION" /* TOLERATE_MISSING_GIT_VERSION */] !== "true") {
       throw e;
     }
@@ -151957,11 +151960,11 @@ async function initConfig(features, inputs) {
       if (generatedFiles.length > 0) {
         config.computedConfig["paths-ignore"] ??= [];
         config.computedConfig["paths-ignore"].push(...generatedFiles);
-        logger.info(
+        logger2.info(
           `Detected ${generatedFiles.length} generated file(s), which will be excluded from analysis: ${joinAtMost(generatedFiles, ", ", 10)}`
         );
       } else {
-        logger.info(`Found no generated files.`);
+        logger2.info(`Found no generated files.`);
       }
       await logGeneratedFilesTelemetry(
         config,
@@ -151969,10 +151972,10 @@ async function initConfig(features, inputs) {
         generatedFiles.length
       );
     } catch (error3) {
-      logger.info(`Cannot ignore generated files: ${getErrorMessage(error3)}`);
+      logger2.info(`Cannot ignore generated files: ${getErrorMessage(error3)}`);
     }
   } else {
-    logger.debug(`Skipping check for generated files.`);
+    logger2.debug(`Skipping check for generated files.`);
   }
   const overlayDatabaseModeResult = await checkOverlayEnablement(
     inputs.codeql,
@@ -151984,7 +151987,7 @@ async function initConfig(features, inputs) {
     config.computedConfig,
     config.repositoryProperties,
     gitVersion,
-    logger
+    logger2
   );
   if (overlayDatabaseModeResult.isSuccess()) {
     const {
@@ -151992,7 +151995,7 @@ async function initConfig(features, inputs) {
       useOverlayDatabaseCaching,
       overlayModeSetExplicitly
     } = overlayDatabaseModeResult.value;
-    logger.info(
+    logger2.info(
       `Using overlay database mode: ${overlayDatabaseMode} ${useOverlayDatabaseCaching ? "with" : "without"} caching.`
     );
     config.overlayDatabaseMode = overlayDatabaseMode;
@@ -152000,7 +152003,7 @@ async function initConfig(features, inputs) {
     config.overlayModeSetExplicitly = overlayModeSetExplicitly;
   } else {
     const overlayDisabledReason = overlayDatabaseModeResult.value;
-    logger.info(
+    logger2.info(
       `Using overlay database mode: ${"none" /* None */} without caching.`
     );
     config.overlayDatabaseMode = "none" /* None */;
@@ -152014,24 +152017,24 @@ async function initConfig(features, inputs) {
   const hasDiffRanges = await prepareDiffInformedAnalysis(
     inputs.codeql,
     inputs.features,
-    logger
+    logger2
   );
   await applyIncrementalAnalysisSettings(
     config,
     hasDiffRanges,
     inputs.codeql,
-    logger
+    logger2
   );
   if (await isTrapCachingEnabled(features, config.overlayDatabaseMode)) {
     const { trapCaches, trapCacheDownloadTime } = await downloadCacheWithTime(
       inputs.codeql,
       config.languages,
-      logger
+      logger2
     );
     config.trapCaches = trapCaches;
     config.trapCacheDownloadTime = trapCacheDownloadTime;
   }
-  await setCppTrapCachingEnvironmentVariables(config, logger);
+  await setCppTrapCachingEnvironmentVariables(config, logger2);
   return config;
 }
 function parseRegistries(registriesInput) {
@@ -152055,20 +152058,20 @@ function isLocal(configPath) {
   }
   return configPath.indexOf("@") === -1;
 }
-function getLocalConfig(logger, configFile, validateConfig) {
+function getLocalConfig(logger2, configFile, validateConfig) {
   if (!fs10.existsSync(configFile)) {
     throw new ConfigurationError(
       getConfigFileDoesNotExistErrorMessage(configFile)
     );
   }
   return parseUserConfig(
-    logger,
+    logger2,
     configFile,
     fs10.readFileSync(configFile, "utf-8"),
     validateConfig
   );
 }
-async function getRemoteConfig(logger, configFile, apiDetails, validateConfig) {
+async function getRemoteConfig(logger2, configFile, apiDetails, validateConfig) {
   const format = new RegExp(
     "(?<owner>[^/]+)/(?<repo>[^/]+)/(?<path>[^@]+)@(?<ref>.*)"
   );
@@ -152097,7 +152100,7 @@ async function getRemoteConfig(logger, configFile, apiDetails, validateConfig) {
     );
   }
   return parseUserConfig(
-    logger,
+    logger2,
     configFile,
     Buffer.from(fileContents, "base64").toString("binary"),
     validateConfig
@@ -152106,22 +152109,22 @@ async function getRemoteConfig(logger, configFile, apiDetails, validateConfig) {
 function getPathToParsedConfigFile(tempDir) {
   return path11.join(tempDir, "config");
 }
-async function saveConfig(config, logger) {
+async function saveConfig(config, logger2) {
   const configString = JSON.stringify(config);
   const configFile = getPathToParsedConfigFile(config.tempDir);
   fs10.mkdirSync(path11.dirname(configFile), { recursive: true });
   fs10.writeFileSync(configFile, configString, "utf8");
-  logger.debug("Saved config:");
-  logger.debug(configString);
+  logger2.debug("Saved config:");
+  logger2.debug(configString);
 }
-async function getConfig(tempDir, logger) {
+async function getConfig(tempDir, logger2) {
   const configFile = getPathToParsedConfigFile(tempDir);
   if (!fs10.existsSync(configFile)) {
     return void 0;
   }
   const configString = fs10.readFileSync(configFile, "utf8");
-  logger.debug("Loaded config:");
-  logger.debug(configString);
+  logger2.debug("Loaded config:");
+  logger2.debug(configString);
   const config = JSON.parse(configString);
   if (config.version === void 0) {
     throw new ConfigurationError(
@@ -152135,7 +152138,7 @@ async function getConfig(tempDir, logger) {
   }
   return config;
 }
-async function generateRegistries(registriesInput, tempDir, logger) {
+async function generateRegistries(registriesInput, tempDir, logger2) {
   const registries = parseRegistries(registriesInput);
   let registriesAuthTokens;
   let qlconfigFile;
@@ -152144,12 +152147,12 @@ async function generateRegistries(registriesInput, tempDir, logger) {
     qlconfigFile = path11.join(tempDir, "qlconfig.yml");
     const qlconfigContents = dump(qlconfig);
     fs10.writeFileSync(qlconfigFile, qlconfigContents, "utf8");
-    logger.debug("Generated qlconfig.yml:");
-    logger.debug(qlconfigContents);
+    logger2.debug("Generated qlconfig.yml:");
+    logger2.debug(qlconfigContents);
     registriesAuthTokens = registries.map((registry) => `${registry.url}=${registry.token}`).join(",");
   }
   if (typeof process.env.CODEQL_REGISTRIES_AUTH === "string") {
-    logger.debug(
+    logger2.debug(
       "Using CODEQL_REGISTRIES_AUTH environment variable to authenticate with registries."
     );
   }
@@ -152193,7 +152196,7 @@ async function wrapEnvironment(env, operation) {
     }
   }
 }
-async function parseBuildModeInput(input, languages, features, logger) {
+async function parseBuildModeInput(input, languages, features, logger2) {
   if (input === void 0) {
     return void 0;
   }
@@ -152205,13 +152208,13 @@ async function parseBuildModeInput(input, languages, features, logger) {
     );
   }
   if (languages.includes("csharp" /* csharp */) && await features.getValue("disable_csharp_buildless" /* DisableCsharpBuildless */)) {
-    logger.warning(
+    logger2.warning(
       "Scanning C# code without a build is temporarily unavailable. Falling back to 'autobuild' build mode."
     );
     return "autobuild" /* Autobuild */;
   }
   if (languages.includes("java" /* java */) && await features.getValue("disable_java_buildless_enabled" /* DisableJavaBuildlessEnabled */)) {
-    logger.warning(
+    logger2.warning(
       "Scanning Java code without a build is temporarily unavailable. Falling back to 'autobuild' build mode."
     );
     return "autobuild" /* Autobuild */;
@@ -152346,10 +152349,10 @@ var OVERLAY_BASE_DATABASE_MAX_UPLOAD_SIZE_BYTES = OVERLAY_BASE_DATABASE_MAX_UPLO
 var CACHE_VERSION2 = 1;
 var CACHE_PREFIX = "codeql-overlay-base-database";
 var MAX_CACHE_OPERATION_MS3 = 6e5;
-async function checkOverlayBaseDatabase(codeql, config, logger, warningPrefix) {
+async function checkOverlayBaseDatabase(codeql, config, logger2, warningPrefix) {
   const baseDatabaseOidsFilePath = getBaseDatabaseOidsFilePath(config);
   if (!fs11.existsSync(baseDatabaseOidsFilePath)) {
-    logger.warning(
+    logger2.warning(
       `${warningPrefix}: ${baseDatabaseOidsFilePath} does not exist`
     );
     return false;
@@ -152359,36 +152362,36 @@ async function checkOverlayBaseDatabase(codeql, config, logger, warningPrefix) {
     try {
       const resolveDatabaseOutput = await codeql.resolveDatabase(dbPath);
       if (resolveDatabaseOutput === void 0 || !("overlayBaseSpecifier" in resolveDatabaseOutput)) {
-        logger.info(`${warningPrefix}: no overlayBaseSpecifier defined`);
+        logger2.info(`${warningPrefix}: no overlayBaseSpecifier defined`);
         return false;
       } else {
-        logger.debug(
+        logger2.debug(
           `Overlay base specifier for ${language} overlay-base database found: ${resolveDatabaseOutput.overlayBaseSpecifier}`
         );
       }
     } catch (e) {
-      logger.warning(`${warningPrefix}: failed to resolve database: ${e}`);
+      logger2.warning(`${warningPrefix}: failed to resolve database: ${e}`);
       return false;
     }
   }
   return true;
 }
-async function cleanupAndUploadOverlayBaseDatabaseToCache(codeql, config, logger) {
+async function cleanupAndUploadOverlayBaseDatabaseToCache(codeql, config, logger2) {
   const overlayDatabaseMode = config.overlayDatabaseMode;
   if (overlayDatabaseMode !== "overlay-base" /* OverlayBase */) {
-    logger.debug(
+    logger2.debug(
       `Overlay database mode is ${overlayDatabaseMode}. Skip uploading overlay-base database to cache.`
     );
     return false;
   }
   if (!config.useOverlayDatabaseCaching) {
-    logger.debug(
+    logger2.debug(
       "Overlay database caching is disabled. Skip uploading overlay-base database to cache."
     );
     return false;
   }
   if (isInTestMode()) {
-    logger.debug(
+    logger2.debug(
       "In test mode. Skip uploading overlay-base database to cache."
     );
     return false;
@@ -152396,7 +152399,7 @@ async function cleanupAndUploadOverlayBaseDatabaseToCache(codeql, config, logger
   const databaseIsValid = await checkOverlayBaseDatabase(
     codeql,
     config,
-    logger,
+    logger2,
     "Abort uploading overlay-base database to cache"
   );
   if (!databaseIsValid) {
@@ -152406,16 +152409,16 @@ async function cleanupAndUploadOverlayBaseDatabaseToCache(codeql, config, logger
     await codeql.databaseCleanupCluster(config, "overlay" /* Overlay */);
   });
   const dbLocation = config.dbLocation;
-  const databaseSizeBytes = await tryGetFolderBytes(dbLocation, logger);
+  const databaseSizeBytes = await tryGetFolderBytes(dbLocation, logger2);
   if (databaseSizeBytes === void 0) {
-    logger.warning(
+    logger2.warning(
       "Failed to determine database size. Skip uploading overlay-base database to cache."
     );
     return false;
   }
   if (databaseSizeBytes > OVERLAY_BASE_DATABASE_MAX_UPLOAD_SIZE_BYTES) {
     const databaseSizeMB = Math.round(databaseSizeBytes / 1e6);
-    logger.warning(
+    logger2.warning(
       `Database size (${databaseSizeMB} MB) exceeds maximum upload size (${OVERLAY_BASE_DATABASE_MAX_UPLOAD_SIZE_MB} MB). Skip uploading overlay-base database to cache.`
     );
     return false;
@@ -152426,9 +152429,9 @@ async function cleanupAndUploadOverlayBaseDatabaseToCache(codeql, config, logger
     config,
     codeQlVersion,
     checkoutPath,
-    logger
+    logger2
   );
-  logger.info(
+  logger2.info(
     `Uploading overlay-base database to Actions cache with key ${cacheSaveKey}`
   );
   try {
@@ -152439,34 +152442,34 @@ async function cleanupAndUploadOverlayBaseDatabaseToCache(codeql, config, logger
       }
     );
     if (cacheId === void 0) {
-      logger.warning("Timed out while uploading overlay-base database");
+      logger2.warning("Timed out while uploading overlay-base database");
       return false;
     }
   } catch (error3) {
-    logger.warning(
+    logger2.warning(
       `Failed to upload overlay-base database to cache: ${error3 instanceof Error ? error3.message : String(error3)}`
     );
     return false;
   }
-  logger.info(`Successfully uploaded overlay-base database from ${dbLocation}`);
+  logger2.info(`Successfully uploaded overlay-base database from ${dbLocation}`);
   return true;
 }
-async function downloadOverlayBaseDatabaseFromCache(codeql, config, logger) {
+async function downloadOverlayBaseDatabaseFromCache(codeql, config, logger2) {
   const overlayDatabaseMode = config.overlayDatabaseMode;
   if (overlayDatabaseMode !== "overlay" /* Overlay */) {
-    logger.debug(
+    logger2.debug(
       `Overlay database mode is ${overlayDatabaseMode}. Skip downloading overlay-base database from cache.`
     );
     return void 0;
   }
   if (!config.useOverlayDatabaseCaching) {
-    logger.debug(
+    logger2.debug(
       "Overlay database caching is disabled. Skip downloading overlay-base database from cache."
     );
     return void 0;
   }
   if (isInTestMode()) {
-    logger.debug(
+    logger2.debug(
       "In test mode. Skip downloading overlay-base database from cache."
     );
     return void 0;
@@ -152477,7 +152480,7 @@ async function downloadOverlayBaseDatabaseFromCache(codeql, config, logger) {
     config,
     codeQlVersion
   );
-  logger.info(
+  logger2.info(
     `Looking in Actions cache for overlay-base database with restore key ${cacheRestoreKeyPrefix}`
   );
   let databaseDownloadDurationMs = 0;
@@ -152517,21 +152520,21 @@ async function downloadOverlayBaseDatabaseFromCache(codeql, config, logger) {
         }
       ),
       () => {
-        logger.info("Timed out downloading overlay-base database from cache");
+        logger2.info("Timed out downloading overlay-base database from cache");
       }
     );
     databaseDownloadDurationMs = Math.round(
       performance.now() - databaseDownloadStart
     );
     if (foundKey === void 0) {
-      logger.info("No overlay-base database found in Actions cache");
+      logger2.info("No overlay-base database found in Actions cache");
       return void 0;
     }
-    logger.info(
+    logger2.info(
       `Downloaded overlay-base database in cache with key ${foundKey}`
     );
   } catch (error3) {
-    logger.warning(
+    logger2.warning(
       `Failed to download overlay-base database from cache: ${error3 instanceof Error ? error3.message : String(error3)}`
     );
     return void 0;
@@ -152539,34 +152542,34 @@ async function downloadOverlayBaseDatabaseFromCache(codeql, config, logger) {
   const databaseIsValid = await checkOverlayBaseDatabase(
     codeql,
     config,
-    logger,
+    logger2,
     "Downloaded overlay-base database is invalid"
   );
   if (!databaseIsValid) {
-    logger.warning("Downloaded overlay-base database failed validation");
+    logger2.warning("Downloaded overlay-base database failed validation");
     return void 0;
   }
-  const databaseSizeBytes = await tryGetFolderBytes(dbLocation, logger);
+  const databaseSizeBytes = await tryGetFolderBytes(dbLocation, logger2);
   if (databaseSizeBytes === void 0) {
-    logger.info(
+    logger2.info(
       "Filesystem error while accessing downloaded overlay-base database"
     );
     return void 0;
   }
-  logger.info(`Successfully downloaded overlay-base database to ${dbLocation}`);
+  logger2.info(`Successfully downloaded overlay-base database to ${dbLocation}`);
   return {
     databaseSizeBytes: Math.round(databaseSizeBytes),
     databaseDownloadDurationMs
   };
 }
-async function getCacheSaveKey(config, codeQlVersion, checkoutPath, logger) {
+async function getCacheSaveKey(config, codeQlVersion, checkoutPath, logger2) {
   let runId = 1;
   let attemptId = 1;
   try {
     runId = getWorkflowRunID();
     attemptId = getWorkflowRunAttempt();
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to get workflow run ID or attempt ID. Reason: ${getErrorMessage(e)}`
     );
   }
@@ -152589,10 +152592,10 @@ async function getCacheKeyPrefixBase(parsedLanguages) {
   const componentsHash = createCacheKeyHash(cacheKeyComponents);
   return `${CACHE_PREFIX}-${CACHE_VERSION2}-${componentsHash}-${languagesComponent}-`;
 }
-async function getCodeQlVersionsForOverlayBaseDatabases(rawLanguages, logger) {
+async function getCodeQlVersionsForOverlayBaseDatabases(rawLanguages, logger2) {
   const languages = rawLanguages.map(parseBuiltInLanguage);
   if (languages.includes(void 0)) {
-    logger.warning(
+    logger2.warning(
       "One or more provided languages are not recognized as built-in languages. Skipping searching for overlay-base databases in cache."
     );
     return void 0;
@@ -152601,15 +152604,15 @@ async function getCodeQlVersionsForOverlayBaseDatabases(rawLanguages, logger) {
     ...new Set(languages.filter((l) => l !== void 0))
   ];
   const cacheKeyPrefix = await getCacheKeyPrefixBase(dedupedLanguages);
-  logger.debug(
+  logger2.debug(
     `Searching for overlay-base databases in Actions cache with prefix ${cacheKeyPrefix}`
   );
   const caches = await listActionsCaches(cacheKeyPrefix);
   if (caches.length === 0) {
-    logger.info("No overlay-base databases found in Actions cache.");
+    logger2.info("No overlay-base databases found in Actions cache.");
     return [];
   }
-  logger.info(
+  logger2.info(
     `Found ${caches.length} overlay-base ${caches.length === 1 ? "database" : "databases"} in the Actions cache.`
   );
   const versionRegex = /^([\d.]+)-/;
@@ -152623,13 +152626,13 @@ async function getCodeQlVersionsForOverlayBaseDatabases(rawLanguages, logger) {
     }
   }
   if (versionSet.size === 0) {
-    logger.info(
+    logger2.info(
       "Could not parse any CodeQL versions from overlay-base database cache keys."
     );
     return [];
   }
   const versions = [...versionSet].sort(semver6.rcompare);
-  logger.info(
+  logger2.info(
     `Found overlay databases for the following CodeQL versions in the Actions cache: ${versions.join(", ")}`
   );
   return versions;
@@ -152674,12 +152677,12 @@ async function getTarVersion() {
     throw new Error("Unknown tar version");
   }
 }
-async function isZstdAvailable(logger) {
-  const foundZstdBinary = await isBinaryAccessible("zstd", logger);
+async function isZstdAvailable(logger2) {
+  const foundZstdBinary = await isBinaryAccessible("zstd", logger2);
   try {
     const tarVersion = await getTarVersion();
     const { type, version } = tarVersion;
-    logger.info(`Found ${type} tar version ${version}.`);
+    logger2.info(`Found ${type} tar version ${version}.`);
     switch (type) {
       case "gnu":
         return {
@@ -152703,13 +152706,13 @@ async function isZstdAvailable(logger) {
         assertNever(type);
     }
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to determine tar version, therefore will assume zstd is not available. The underlying error was: ${e}`
     );
     return { available: false, foundZstdBinary };
   }
 }
-async function extract(tarPath, dest, compressionMethod, tarVersion, logger) {
+async function extract(tarPath, dest, compressionMethod, tarVersion, logger2) {
   fs12.mkdirSync(dest, { recursive: true });
   switch (compressionMethod) {
     case "gzip":
@@ -152720,13 +152723,13 @@ async function extract(tarPath, dest, compressionMethod, tarVersion, logger) {
           "Could not determine tar version, which is required to extract a Zstandard archive."
         );
       }
-      await extractTarZst(tarPath, dest, tarVersion, logger);
+      await extractTarZst(tarPath, dest, tarVersion, logger2);
       return dest;
     }
   }
 }
-async function extractTarZst(tar, dest, tarVersion, logger) {
-  logger.debug(
+async function extractTarZst(tar, dest, tarVersion, logger2) {
+  logger2.debug(
     `Extracting to ${dest}.${tar instanceof stream.Readable ? ` Input stream has high water mark ${tar.readableHighWaterMark}.` : ""}`
   );
   try {
@@ -152776,7 +152779,7 @@ async function extractTarZst(tar, dest, tarVersion, logger) {
       });
     });
   } catch (e) {
-    await cleanUpPath(dest, "extraction destination directory", logger);
+    await cleanUpPath(dest, "extraction destination directory", logger2);
     throw e;
   }
 }
@@ -152821,13 +152824,13 @@ function makeStreamedToolsDownloadDurations(combinedDurationMs) {
     streamExtraction: true
   };
 }
-async function downloadAndExtract(codeqlURL, compressionMethod, dest, authorization, headers, tarVersion, logger) {
-  logger.info(
+async function downloadAndExtract(codeqlURL, compressionMethod, dest, authorization, headers, tarVersion, logger2) {
+  logger2.info(
     `Downloading CodeQL tools from ${codeqlURL} . This may take a while.`
   );
   try {
     if (compressionMethod === "zstd" && process.platform === "linux") {
-      logger.info(`Streaming the extraction of the CodeQL bundle.`);
+      logger2.info(`Streaming the extraction of the CodeQL bundle.`);
       const toolsInstallStart = import_perf_hooks2.performance.now();
       await downloadAndExtractZstdWithStreaming(
         codeqlURL,
@@ -152835,12 +152838,12 @@ async function downloadAndExtract(codeqlURL, compressionMethod, dest, authorizat
         authorization,
         headers,
         tarVersion,
-        logger
+        logger2
       );
       const combinedDurationMs = Math.round(
         import_perf_hooks2.performance.now() - toolsInstallStart
       );
-      logger.info(
+      logger2.info(
         `Finished downloading and extracting CodeQL bundle to ${dest} (${formatDuration(
           combinedDurationMs
         )}).`
@@ -152856,7 +152859,7 @@ async function downloadAndExtract(codeqlURL, compressionMethod, dest, authorizat
       `Failed to download and extract CodeQL bundle using streaming with error: ${getErrorMessage(e)}`
     );
     core9.warning(`Falling back to downloading the bundle before extracting.`);
-    await cleanUpPath(dest, "CodeQL bundle", logger);
+    await cleanUpPath(dest, "CodeQL bundle", logger2);
   }
   const toolsDownloadStart = import_perf_hooks2.performance.now();
   const archivedBundlePath = await toolcache2.downloadTool(
@@ -152866,30 +152869,30 @@ async function downloadAndExtract(codeqlURL, compressionMethod, dest, authorizat
     headers
   );
   const downloadDurationMs = Math.round(import_perf_hooks2.performance.now() - toolsDownloadStart);
-  logger.info(
+  logger2.info(
     `Finished downloading CodeQL bundle to ${archivedBundlePath} (${formatDuration(
       downloadDurationMs
     )}).`
   );
   let extractionDurationMs;
   try {
-    logger.info("Extracting CodeQL bundle.");
+    logger2.info("Extracting CodeQL bundle.");
     const extractionStart = import_perf_hooks2.performance.now();
     await extract(
       archivedBundlePath,
       dest,
       compressionMethod,
       tarVersion,
-      logger
+      logger2
     );
     extractionDurationMs = Math.round(import_perf_hooks2.performance.now() - extractionStart);
-    logger.info(
+    logger2.info(
       `Finished extracting CodeQL bundle to ${dest} (${formatDuration(
         extractionDurationMs
       )}).`
     );
   } finally {
-    await cleanUpPath(archivedBundlePath, "CodeQL bundle archive", logger);
+    await cleanUpPath(archivedBundlePath, "CodeQL bundle archive", logger2);
   }
   return {
     compressionMethod,
@@ -152900,7 +152903,7 @@ async function downloadAndExtract(codeqlURL, compressionMethod, dest, authorizat
     )
   };
 }
-async function downloadAndExtractZstdWithStreaming(codeqlURL, dest, authorization, headers, tarVersion, logger) {
+async function downloadAndExtractZstdWithStreaming(codeqlURL, dest, authorization, headers, tarVersion, logger2) {
   fs13.mkdirSync(dest, { recursive: true });
   const agent = new import_http_client.HttpClient().getAgent(codeqlURL);
   headers = Object.assign(
@@ -152926,7 +152929,7 @@ async function downloadAndExtractZstdWithStreaming(codeqlURL, dest, authorizatio
       `Failed to download CodeQL bundle from ${codeqlURL}. HTTP status code: ${response.statusCode}.`
     );
   }
-  await extractTarZst(response, dest, tarVersion, logger);
+  await extractTarZst(response, dest, tarVersion, logger2);
 }
 function getToolcacheDirectory(version) {
   return path12.join(
@@ -152936,10 +152939,10 @@ function getToolcacheDirectory(version) {
     os3.arch() || ""
   );
 }
-function writeToolcacheMarkerFile(extractedPath, logger) {
+function writeToolcacheMarkerFile(extractedPath, logger2) {
   const markerFilePath = `${extractedPath}.complete`;
   fs13.writeFileSync(markerFilePath, "");
-  logger.info(`Created toolcache marker file ${markerFilePath}`);
+  logger2.info(`Created toolcache marker file ${markerFilePath}`);
 }
 function sanitizeUrlForStatusReport(url2) {
   return ["github/codeql-action", "dsp-testing/codeql-cli-nightlies"].some(
@@ -152978,17 +152981,17 @@ function getCodeQLBundleName(compressionMethod) {
   }
   return `codeql-bundle-${platform2}${extension}`;
 }
-function getCodeQLActionRepository(logger) {
+function getCodeQLActionRepository(logger2) {
   if (isRunningLocalAction()) {
-    logger.info(
+    logger2.info(
       "The CodeQL Action is checked out locally. Using the default CodeQL Action repository."
     );
     return CODEQL_DEFAULT_ACTION_REPOSITORY;
   }
   return getRequiredEnvParam("GITHUB_ACTION_REPOSITORY");
 }
-async function getCodeQLBundleDownloadURL(tagName, apiDetails, compressionMethod, logger) {
-  const codeQLActionRepository = getCodeQLActionRepository(logger);
+async function getCodeQLBundleDownloadURL(tagName, apiDetails, compressionMethod, logger2) {
+  const codeQLActionRepository = getCodeQLActionRepository(logger2);
   const potentialDownloadSources = [
     // This GitHub instance, and this Action.
     [apiDetails.url, codeQLActionRepository],
@@ -153017,37 +153020,37 @@ async function getCodeQLBundleDownloadURL(tagName, apiDetails, compressionMethod
       });
       for (const asset of release2.data.assets) {
         if (asset.name === codeQLBundleName) {
-          logger.info(
+          logger2.info(
             `Found CodeQL bundle ${codeQLBundleName} in ${repository} on ${apiURL} with URL ${asset.url}.`
           );
           return asset.url;
         }
       }
     } catch (e) {
-      logger.info(
+      logger2.info(
         `Looked for CodeQL bundle ${codeQLBundleName} in ${repository} on ${apiURL} but got error ${e}.`
       );
     }
   }
   return `https://github.com/${CODEQL_DEFAULT_ACTION_REPOSITORY}/releases/download/${tagName}/${codeQLBundleName}`;
 }
-function tryGetBundleVersionFromTagName(tagName, logger) {
+function tryGetBundleVersionFromTagName(tagName, logger2) {
   const match = tagName.match(/^codeql-bundle-(.*)$/);
   if (match === null || match.length < 2) {
-    logger.debug(`Could not determine bundle version from tag ${tagName}.`);
+    logger2.debug(`Could not determine bundle version from tag ${tagName}.`);
     return void 0;
   }
   return match[1];
 }
-function tryGetTagNameFromUrl(url2, logger) {
+function tryGetTagNameFromUrl(url2, logger2) {
   const matches = [...url2.matchAll(/\/(codeql-bundle-[^/]*)\//g)];
   if (matches.length === 0) {
-    logger.debug(`Could not determine tag name for URL ${url2}.`);
+    logger2.debug(`Could not determine tag name for URL ${url2}.`);
     return void 0;
   }
   const match = matches[matches.length - 1];
   if (match?.length !== 2) {
-    logger.debug(
+    logger2.debug(
       `Could not determine tag name for URL ${url2}. Matched ${JSON.stringify(
         match
       )}.`
@@ -153056,9 +153059,9 @@ function tryGetTagNameFromUrl(url2, logger) {
   }
   return match[1];
 }
-function convertToSemVer(version, logger) {
+function convertToSemVer(version, logger2) {
   if (!semver9.valid(version)) {
-    logger.debug(
+    logger2.debug(
       `Bundle version ${version} is not in SemVer format. Will treat it as pre-release 0.0.0-${version}.`
     );
     version = `0.0.0-${version}`;
@@ -153069,14 +153072,14 @@ function convertToSemVer(version, logger) {
   }
   return s;
 }
-async function findOverridingToolsInCache(humanReadableVersion, logger) {
+async function findOverridingToolsInCache(humanReadableVersion, logger2) {
   const candidates = toolcache3.findAllVersions("CodeQL").filter(isGoodVersion).map((version) => ({
     folder: toolcache3.find("CodeQL", version),
     version
   })).filter(({ folder }) => fs14.existsSync(path13.join(folder, "pinned-version")));
   if (candidates.length === 1) {
     const candidate = candidates[0];
-    logger.debug(
+    logger2.debug(
       `CodeQL tools version ${candidate.version} in toolcache overriding version ${humanReadableVersion}.`
     );
     return {
@@ -153085,17 +153088,17 @@ async function findOverridingToolsInCache(humanReadableVersion, logger) {
       toolsVersion: candidate.version
     };
   } else if (candidates.length === 0) {
-    logger.debug(
+    logger2.debug(
       "Did not find any candidate pinned versions of the CodeQL tools in the toolcache."
     );
   } else {
-    logger.debug(
+    logger2.debug(
       "Could not use CodeQL tools from the toolcache since more than one candidate pinned version was found in the toolcache."
     );
   }
   return void 0;
 }
-async function getEnabledVersionsWithOverlayBaseDatabases(defaultCliVersion, rawLanguages, features, logger) {
+async function getEnabledVersionsWithOverlayBaseDatabases(defaultCliVersion, rawLanguages, features, logger2) {
   if (rawLanguages === void 0 || rawLanguages.length === 0) {
     return [];
   }
@@ -153110,10 +153113,10 @@ async function getEnabledVersionsWithOverlayBaseDatabases(defaultCliVersion, raw
   try {
     cachedVersions = await getCodeQlVersionsForOverlayBaseDatabases(
       rawLanguages,
-      logger
+      logger2
     );
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Could not list overlay-base databases in the Actions cache while choosing a default CodeQL CLI version, falling back to the highest enabled version. Details: ${getErrorMessage(e)}`
     );
     return [];
@@ -153147,14 +153150,14 @@ async function getEnabledVersionsWithOverlayBaseDatabases(defaultCliVersion, raw
     );
   }
   if (isDryRun) {
-    logger.debug(
+    logger2.debug(
       `Overlay-aware default CodeQL version selection is running in dry-run mode. Would have used version ${overlayVersions[0].cliVersion}.`
     );
     return [];
   }
   return overlayVersions;
 }
-async function resolveDefaultCliVersion(defaultCliVersion, rawLanguages, useOverlayAwareDefaultCliVersion, features, logger) {
+async function resolveDefaultCliVersion(defaultCliVersion, rawLanguages, useOverlayAwareDefaultCliVersion, features, logger2) {
   if (!useOverlayAwareDefaultCliVersion || !isAnalyzingPullRequest()) {
     return defaultCliVersion.enabledVersions[0];
   }
@@ -153162,19 +153165,19 @@ async function resolveDefaultCliVersion(defaultCliVersion, rawLanguages, useOver
     defaultCliVersion,
     rawLanguages,
     features,
-    logger
+    logger2
   );
   if (overlayVersions.length > 0) {
-    logger.info(
+    logger2.info(
       `Using CodeQL version ${overlayVersions[0].cliVersion} since this is the highest enabled version that has a cached overlay-base database.`
     );
     return overlayVersions[0];
   }
   return defaultCliVersion.enabledVersions[0];
 }
-async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useOverlayAwareDefaultCliVersion, apiDetails, variant, tarSupportsZstd, features, logger) {
+async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useOverlayAwareDefaultCliVersion, apiDetails, variant, tarSupportsZstd, features, logger2) {
   if (toolsInput && !isReservedToolsValue(toolsInput) && !toolsInput.startsWith("http")) {
-    logger.info(`Using CodeQL CLI from local path ${toolsInput}`);
+    logger2.info(`Using CodeQL CLI from local path ${toolsInput}`);
     const compressionMethod2 = inferCompressionMethod(toolsInput);
     if (compressionMethod2 === void 0) {
       throw new ConfigurationError(
@@ -153197,7 +153200,7 @@ async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useO
   const nightlyRequestedByToolsInput = toolsInput !== void 0 && CODEQL_NIGHTLY_TOOLS_INPUTS.includes(toolsInput);
   if (forceNightly || nightlyRequestedByToolsInput) {
     if (forceNightly) {
-      logger.info(
+      logger2.info(
         `Using the latest CodeQL CLI nightly, as forced by the ${"force_nightly" /* ForceNightly */} feature flag.`
       );
       addNoLanguageDiagnostic(
@@ -153217,21 +153220,21 @@ async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useO
         )
       );
     } else {
-      logger.info(
+      logger2.info(
         `Using the latest CodeQL CLI nightly, as requested by 'tools: ${toolsInput}'.`
       );
     }
-    toolsInput = await getNightlyToolsUrl(logger);
+    toolsInput = await getNightlyToolsUrl(logger2);
   }
   const forceShippedTools = toolsInput && CODEQL_BUNDLE_VERSION_ALIAS.includes(toolsInput);
   if (forceShippedTools) {
     cliVersion2 = cliVersion;
     tagName = bundleVersion;
-    logger.info(
+    logger2.info(
       `'tools: ${toolsInput}' was requested, so using CodeQL version ${cliVersion2}, the version shipped with the Action.`
     );
     if (toolsInput === "latest") {
-      logger.warning(
+      logger2.warning(
         "`tools: latest` has been renamed to `tools: linked`, but the old name is still supported. No action is required."
       );
     }
@@ -153242,26 +153245,26 @@ async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useO
     );
     const allowToolcacheValue = allowToolcacheValueFF && (isDynamicWorkflow() || isInTestMode());
     if (allowToolcacheValue) {
-      logger.info(
+      logger2.info(
         `Attempting to use the latest CodeQL CLI version in the toolcache, as requested by 'tools: ${toolsInput}'.`
       );
-      latestToolcacheVersion = getLatestToolcacheVersion(logger);
+      latestToolcacheVersion = getLatestToolcacheVersion(logger2);
       if (latestToolcacheVersion) {
         cliVersion2 = latestToolcacheVersion;
       }
     }
     if (latestToolcacheVersion === void 0) {
       if (allowToolcacheValue) {
-        logger.info(
+        logger2.info(
           `Found no CodeQL CLI in the toolcache, ignoring 'tools: ${toolsInput}'...`
         );
       } else {
         if (allowToolcacheValueFF) {
-          logger.warning(
+          logger2.warning(
             `Ignoring 'tools: ${toolsInput}' because the workflow was not triggered dynamically.`
           );
         } else {
-          logger.info(
+          logger2.info(
             `Ignoring 'tools: ${toolsInput}' because the feature is not enabled.`
           );
         }
@@ -153271,18 +153274,18 @@ async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useO
         rawLanguages,
         useOverlayAwareDefaultCliVersion,
         features,
-        logger
+        logger2
       );
       cliVersion2 = version.cliVersion;
       tagName = version.tagName;
     }
   } else if (toolsInput !== void 0) {
-    tagName = tryGetTagNameFromUrl(toolsInput, logger);
+    tagName = tryGetTagNameFromUrl(toolsInput, logger2);
     url2 = toolsInput;
     if (tagName) {
-      const bundleVersion3 = tryGetBundleVersionFromTagName(tagName, logger);
+      const bundleVersion3 = tryGetBundleVersionFromTagName(tagName, logger2);
       if (bundleVersion3 && semver9.valid(bundleVersion3)) {
-        cliVersion2 = convertToSemVer(bundleVersion3, logger);
+        cliVersion2 = convertToSemVer(bundleVersion3, logger2);
       }
     }
   } else {
@@ -153291,25 +153294,25 @@ async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useO
       rawLanguages,
       useOverlayAwareDefaultCliVersion,
       features,
-      logger
+      logger2
     );
     cliVersion2 = version.cliVersion;
     tagName = version.tagName;
   }
-  const bundleVersion2 = tagName && tryGetBundleVersionFromTagName(tagName, logger);
-  const humanReadableVersion = cliVersion2 ?? (bundleVersion2 && convertToSemVer(bundleVersion2, logger)) ?? tagName ?? url2 ?? "unknown";
-  logger.debug(
+  const bundleVersion2 = tagName && tryGetBundleVersionFromTagName(tagName, logger2);
+  const humanReadableVersion = cliVersion2 ?? (bundleVersion2 && convertToSemVer(bundleVersion2, logger2)) ?? tagName ?? url2 ?? "unknown";
+  logger2.debug(
     `Attempting to obtain CodeQL tools. CLI version: ${cliVersion2 ?? "unknown"}, bundle tag name: ${tagName ?? "unknown"}, URL: ${url2 ?? "unspecified"}.`
   );
   let codeqlFolder;
   if (cliVersion2) {
     codeqlFolder = toolcache3.find("CodeQL", cliVersion2);
     if (!codeqlFolder) {
-      logger.debug(
+      logger2.debug(
         `Didn't find a version of the CodeQL tools in the toolcache with a version number exactly matching ${cliVersion2}.`
       );
       const allVersions = toolcache3.findAllVersions("CodeQL");
-      logger.debug(
+      logger2.debug(
         `Found the following versions of the CodeQL tools in the toolcache: ${JSON.stringify(
           allVersions
         )}.`
@@ -153318,19 +153321,19 @@ async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useO
         (version) => version.startsWith(`${cliVersion2}-`)
       );
       if (candidateVersions.length === 1) {
-        logger.debug(
+        logger2.debug(
           `Exactly one version of the CodeQL tools starting with ${cliVersion2} found in the toolcache, using that.`
         );
         codeqlFolder = toolcache3.find("CodeQL", candidateVersions[0]);
       } else if (candidateVersions.length === 0) {
-        logger.debug(
+        logger2.debug(
           `Didn't find any versions of the CodeQL tools starting with ${cliVersion2} in the toolcache. Trying next fallback method.`
         );
       } else {
-        logger.warning(
+        logger2.warning(
           `Found ${candidateVersions.length} versions of the CodeQL tools starting with ${cliVersion2} in the toolcache, but at most one was expected.`
         );
-        logger.debug("Trying next fallback method.");
+        logger2.debug("Trying next fallback method.");
       }
     }
   }
@@ -153338,32 +153341,32 @@ async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useO
     const fallbackVersion = await tryGetFallbackToolcacheVersion(
       cliVersion2,
       tagName,
-      logger
+      logger2
     );
     if (fallbackVersion) {
       codeqlFolder = toolcache3.find("CodeQL", fallbackVersion);
     } else {
-      logger.debug(
+      logger2.debug(
         `Could not determine a fallback toolcache version number for CodeQL tools version ${humanReadableVersion}.`
       );
     }
   }
   if (codeqlFolder) {
-    logger.info(
+    logger2.info(
       `Found CodeQL tools version ${humanReadableVersion} in the toolcache.`
     );
   } else {
-    logger.info(
+    logger2.info(
       `Did not find CodeQL tools version ${humanReadableVersion} in the toolcache.`
     );
   }
   if (codeqlFolder) {
     if (cliVersion2) {
-      logger.info(
+      logger2.info(
         `Using CodeQL CLI version ${cliVersion2} from toolcache at ${codeqlFolder}`
       );
     } else {
-      logger.info(`Using CodeQL CLI from toolcache at ${codeqlFolder}`);
+      logger2.info(`Using CodeQL CLI from toolcache at ${codeqlFolder}`);
     }
     return {
       codeqlFolder,
@@ -153374,7 +153377,7 @@ async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useO
   if (variant === "GitHub Enterprise Server" /* GHES */ && !forceShippedTools && !toolsInput) {
     const result = await findOverridingToolsInCache(
       humanReadableVersion,
-      logger
+      logger2
     );
     if (result !== void 0) {
       return result;
@@ -153387,7 +153390,7 @@ async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useO
       tagName,
       apiDetails,
       compressionMethod,
-      logger
+      logger2
     );
   } else {
     const method = inferCompressionMethod(url2);
@@ -153399,12 +153402,12 @@ async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useO
     compressionMethod = method;
   }
   if (cliVersion2) {
-    logger.info(`Using CodeQL CLI version ${cliVersion2} sourced from ${url2} .`);
+    logger2.info(`Using CodeQL CLI version ${cliVersion2} sourced from ${url2} .`);
   } else {
-    logger.info(`Using CodeQL CLI sourced from ${url2} .`);
+    logger2.info(`Using CodeQL CLI sourced from ${url2} .`);
   }
   return {
-    bundleVersion: tagName && tryGetBundleVersionFromTagName(tagName, logger),
+    bundleVersion: tagName && tryGetBundleVersionFromTagName(tagName, logger2),
     cliVersion: cliVersion2,
     codeqlURL: url2,
     compressionMethod,
@@ -153412,18 +153415,18 @@ async function getCodeQLSource(toolsInput, defaultCliVersion, rawLanguages, useO
     toolsVersion: cliVersion2 ?? humanReadableVersion
   };
 }
-async function tryGetFallbackToolcacheVersion(cliVersion2, tagName, logger) {
-  const bundleVersion2 = tryGetBundleVersionFromTagName(tagName, logger);
+async function tryGetFallbackToolcacheVersion(cliVersion2, tagName, logger2) {
+  const bundleVersion2 = tryGetBundleVersionFromTagName(tagName, logger2);
   if (!bundleVersion2) {
     return void 0;
   }
-  const fallbackVersion = convertToSemVer(bundleVersion2, logger);
-  logger.debug(
+  const fallbackVersion = convertToSemVer(bundleVersion2, logger2);
+  logger2.debug(
     `Computed a fallback toolcache version number of ${fallbackVersion} for CodeQL version ${cliVersion2 ?? tagName}.`
   );
   return fallbackVersion;
 }
-var downloadCodeQL = async function(codeqlURL, compressionMethod, maybeBundleVersion, maybeCliVersion, apiDetails, tarVersion, tempDir, logger) {
+var downloadCodeQL = async function(codeqlURL, compressionMethod, maybeBundleVersion, maybeCliVersion, apiDetails, tarVersion, tempDir, logger2) {
   const parsedCodeQLURL = new URL(codeqlURL);
   const searchParams = new URLSearchParams(parsedCodeQLURL.search);
   const headers = {
@@ -153431,10 +153434,10 @@ var downloadCodeQL = async function(codeqlURL, compressionMethod, maybeBundleVer
   };
   let authorization = void 0;
   if (searchParams.has("token")) {
-    logger.debug("CodeQL tools URL contains an authorization token.");
+    logger2.debug("CodeQL tools URL contains an authorization token.");
   } else {
     authorization = getAuthorizationHeaderFor(
-      logger,
+      logger2,
       apiDetails,
       codeqlURL
     );
@@ -153442,7 +153445,7 @@ var downloadCodeQL = async function(codeqlURL, compressionMethod, maybeBundleVer
   const toolcacheInfo = getToolcacheDestinationInfo(
     maybeBundleVersion,
     maybeCliVersion,
-    logger
+    logger2
   );
   const extractedBundlePath = toolcacheInfo?.path ?? getTempExtractionDir(tempDir);
   const statusReport = await downloadAndExtract(
@@ -153452,10 +153455,10 @@ var downloadCodeQL = async function(codeqlURL, compressionMethod, maybeBundleVer
     authorization,
     { "User-Agent": "CodeQL Action", ...headers },
     tarVersion,
-    logger
+    logger2
   );
   if (!toolcacheInfo) {
-    logger.debug(
+    logger2.debug(
       `Could not cache CodeQL tools because we could not determine the bundle version from the URL ${codeqlURL}.`
     );
     return {
@@ -153464,19 +153467,19 @@ var downloadCodeQL = async function(codeqlURL, compressionMethod, maybeBundleVer
       toolsVersion: maybeCliVersion ?? "unknown"
     };
   }
-  writeToolcacheMarkerFile(toolcacheInfo.path, logger);
+  writeToolcacheMarkerFile(toolcacheInfo.path, logger2);
   return {
     codeqlFolder: extractedBundlePath,
     statusReport,
     toolsVersion: maybeCliVersion ?? toolcacheInfo.version
   };
 };
-function getToolcacheDestinationInfo(maybeBundleVersion, maybeCliVersion, logger) {
+function getToolcacheDestinationInfo(maybeBundleVersion, maybeCliVersion, logger2) {
   if (maybeBundleVersion) {
     const version = getCanonicalToolcacheVersion(
       maybeCliVersion,
       maybeBundleVersion,
-      logger
+      logger2
     );
     return {
       path: getToolcacheDirectory(version),
@@ -153485,19 +153488,19 @@ function getToolcacheDestinationInfo(maybeBundleVersion, maybeCliVersion, logger
   }
   return void 0;
 }
-function getCanonicalToolcacheVersion(cliVersion2, bundleVersion2, logger) {
+function getCanonicalToolcacheVersion(cliVersion2, bundleVersion2, logger2) {
   if (!cliVersion2?.match(/^[0-9]+\.[0-9]+\.[0-9]+$/)) {
-    return convertToSemVer(bundleVersion2, logger);
+    return convertToSemVer(bundleVersion2, logger2);
   }
   return cliVersion2;
 }
-async function setupCodeQLBundle(toolsInput, apiDetails, tempDir, variant, defaultCliVersion, rawLanguages, useOverlayAwareDefaultCliVersion, features, logger) {
-  if (!await isBinaryAccessible("tar", logger)) {
+async function setupCodeQLBundle(toolsInput, apiDetails, tempDir, variant, defaultCliVersion, rawLanguages, useOverlayAwareDefaultCliVersion, features, logger2) {
+  if (!await isBinaryAccessible("tar", logger2)) {
     throw new ConfigurationError(
       "Could not find tar in PATH, so unable to extract CodeQL bundle."
     );
   }
-  const zstdAvailability = await isZstdAvailable(logger);
+  const zstdAvailability = await isZstdAvailable(logger2);
   const source = await getCodeQLSource(
     toolsInput,
     defaultCliVersion,
@@ -153507,7 +153510,7 @@ async function setupCodeQLBundle(toolsInput, apiDetails, tempDir, variant, defau
     variant,
     zstdAvailability.available,
     features,
-    logger
+    logger2
   );
   let codeqlFolder;
   let toolsVersion = source.toolsVersion;
@@ -153520,14 +153523,14 @@ async function setupCodeQLBundle(toolsInput, apiDetails, tempDir, variant, defau
         getTempExtractionDir(tempDir),
         source.compressionMethod,
         zstdAvailability.version,
-        logger
+        logger2
       );
       toolsSource = "LOCAL" /* Local */;
       break;
     }
     case "toolcache":
       codeqlFolder = source.codeqlFolder;
-      logger.debug(`CodeQL found in cache ${codeqlFolder}`);
+      logger2.debug(`CodeQL found in cache ${codeqlFolder}`);
       toolsSource = "TOOLCACHE" /* Toolcache */;
       break;
     case "download": {
@@ -153539,7 +153542,7 @@ async function setupCodeQLBundle(toolsInput, apiDetails, tempDir, variant, defau
         apiDetails,
         zstdAvailability.version,
         tempDir,
-        logger
+        logger2
       );
       toolsVersion = result.toolsVersion;
       codeqlFolder = result.codeqlFolder;
@@ -153567,8 +153570,8 @@ async function useZstdBundle(cliVersion2, tarSupportsZstd) {
 function getTempExtractionDir(tempDir) {
   return path13.join(tempDir, v4_default());
 }
-async function getNightlyToolsUrl(logger) {
-  const zstdAvailability = await isZstdAvailable(logger);
+async function getNightlyToolsUrl(logger2) {
+  const zstdAvailability = await isZstdAvailable(logger2);
   const compressionMethod = await useZstdBundle(
     CODEQL_VERSION_ZSTD_BUNDLE,
     zstdAvailability.available
@@ -153592,16 +153595,16 @@ async function getNightlyToolsUrl(logger) {
     );
   }
 }
-function getLatestToolcacheVersion(logger) {
+function getLatestToolcacheVersion(logger2) {
   const allVersions = toolcache3.findAllVersions("CodeQL").sort((a, b) => semver9.compare(b, a));
-  logger.debug(
+  logger2.debug(
     `Found the following versions of the CodeQL tools in the toolcache: ${JSON.stringify(
       allVersions
     )}.`
   );
   if (allVersions.length > 0) {
     const latestToolcacheVersion = allVersions[0];
-    logger.info(
+    logger2.info(
       `CLI version ${latestToolcacheVersion} is the latest version in the toolcache.`
     );
     return latestToolcacheVersion;
@@ -153624,9 +153627,9 @@ async function shouldEnableIndirectTracing(codeql, config) {
   }
   return asyncSome(config.languages, (l) => codeql.isTracedLanguage(l));
 }
-async function endTracingForCluster(codeql, config, logger) {
+async function endTracingForCluster(codeql, config, logger2) {
   if (!await shouldEnableIndirectTracing(codeql, config)) return;
-  logger.info(
+  logger2.info(
     "Unsetting build tracing environment variables. Subsequent steps of this job will not be traced."
   );
   const envVariablesFile = path14.resolve(
@@ -153700,7 +153703,7 @@ var CODEQL_NEXT_MINIMUM_VERSION = "2.19.4";
 var GHES_VERSION_MOST_RECENTLY_DEPRECATED = "3.15";
 var GHES_MOST_RECENT_DEPRECATION_DATE = "2026-04-09";
 var EXTRACTION_DEBUG_MODE_VERBOSITY = "progress++";
-async function setupCodeQL(toolsInput, apiDetails, tempDir, variant, defaultCliVersion, rawLanguages, useOverlayAwareDefaultCliVersion, features, logger, checkVersion) {
+async function setupCodeQL(toolsInput, apiDetails, tempDir, variant, defaultCliVersion, rawLanguages, useOverlayAwareDefaultCliVersion, features, logger2, checkVersion) {
   try {
     const {
       codeqlFolder,
@@ -153717,9 +153720,9 @@ async function setupCodeQL(toolsInput, apiDetails, tempDir, variant, defaultCliV
       rawLanguages,
       useOverlayAwareDefaultCliVersion,
       features,
-      logger
+      logger2
     );
-    logger.debug(
+    logger2.debug(
       `Bundle download status report: ${JSON.stringify(
         toolsDownloadStatusReport
       )}`
@@ -153797,7 +153800,7 @@ async function getCodeQLForCmd(cmd, checkVersion) {
     async isScannedLanguage(language) {
       return !await this.isTracedLanguage(language);
     },
-    async databaseInitCluster(config, sourceRoot, processName, qlconfigFile, logger) {
+    async databaseInitCluster(config, sourceRoot, processName, qlconfigFile, logger2) {
       const extraArgs = config.languages.map(
         (language) => `--language=${language}`
       );
@@ -153808,7 +153811,7 @@ async function getCodeQLForCmd(cmd, checkVersion) {
       }
       const codeScanningConfigFile = await writeCodeScanningConfigFile(
         config,
-        logger
+        logger2
       );
       const externalRepositoryToken = getOptionalInput(
         "external-repository-token"
@@ -153828,7 +153831,7 @@ async function getCodeQLForCmd(cmd, checkVersion) {
         const overlayChangesFile = await writeOverlayChangesFile(
           config,
           sourceRoot,
-          logger
+          logger2
         );
         extraArgs.push(`--overlay-changes=${overlayChangesFile}`);
       } else if (overlayDatabaseMode === "overlay-base" /* OverlayBase */) {
@@ -154220,18 +154223,18 @@ async function runCliJson(cmd, args = [], opts = {}) {
     throw Error(`Invalid JSON output from \`${args.join(" ")}\`: ${output}`);
   }
 }
-async function writeCodeScanningConfigFile(config, logger) {
+async function writeCodeScanningConfigFile(config, logger2) {
   const codeScanningConfigFile = getGeneratedCodeScanningConfigPath(config);
   const augmentedConfig = appendExtraQueryExclusions(
     config.extraQueryExclusions,
     config.computedConfig
   );
-  logger.info(
+  logger2.info(
     `Writing augmented user configuration file to ${codeScanningConfigFile}`
   );
-  logger.startGroup("Augmented user configuration file contents");
-  logger.info(dump(augmentedConfig));
-  logger.endGroup();
+  logger2.startGroup("Augmented user configuration file contents");
+  logger2.info(dump(augmentedConfig));
+  logger2.endGroup();
   fs16.writeFileSync(codeScanningConfigFile, dump(augmentedConfig));
   return codeScanningConfigFile;
 }
@@ -154274,9 +154277,9 @@ async function getJobRunUuidSarifOptions() {
 }
 
 // src/autobuild.ts
-async function determineAutobuildLanguages(codeql, config, logger) {
+async function determineAutobuildLanguages(codeql, config, logger2) {
   if (config.buildMode === "none" /* None */ || config.buildMode === "manual" /* Manual */) {
-    logger.info(
+    logger2.info(
       `Using build mode "${config.buildMode}", nothing to autobuild. See ${"https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages#codeql-build-modes" /* CODEQL_BUILD_MODES */} for more information.`
     );
     return void 0;
@@ -154286,7 +154289,7 @@ async function determineAutobuildLanguages(codeql, config, logger) {
     async (language) => await codeql.isTracedLanguage(language)
   );
   if (autobuildLanguages.length === 0) {
-    logger.info(
+    logger2.info(
       "None of the languages in this project require extra build steps"
     );
     return void 0;
@@ -154301,9 +154304,9 @@ async function determineAutobuildLanguages(codeql, config, logger) {
   if (autobuildLanguages.length !== autobuildLanguagesWithoutGo.length) {
     languages.push("go" /* go */);
   }
-  logger.debug(`Will autobuild ${languages.join(" and ")}.`);
+  logger2.debug(`Will autobuild ${languages.join(" and ")}.`);
   if (autobuildLanguagesWithoutGo.length > 1) {
-    logger.warning(
+    logger2.warning(
       `We will only automatically build ${languages.join(
         " and "
       )} code. If you wish to scan ${autobuildLanguagesWithoutGo.slice(1).join(
@@ -154313,7 +154316,7 @@ async function determineAutobuildLanguages(codeql, config, logger) {
   }
   return languages;
 }
-async function setupCppAutobuild(codeql, logger) {
+async function setupCppAutobuild(codeql, logger2) {
   const envVar = featureConfig["cpp_dependency_installation_enabled" /* CppDependencyInstallation */].envVar;
   const featureName = "C++ automatic installation of dependencies";
   const gitHubVersion = await getGitHubVersion();
@@ -154322,30 +154325,30 @@ async function setupCppAutobuild(codeql, logger) {
     gitHubVersion,
     repositoryNwo,
     getTemporaryDirectory(),
-    logger
+    logger2
   );
   if (await features.getValue("cpp_dependency_installation_enabled" /* CppDependencyInstallation */, codeql)) {
     if (process.env["RUNNER_ENVIRONMENT"] === "self-hosted" && process.env[envVar] !== "true") {
-      logger.info(
+      logger2.info(
         `Disabling ${featureName} as we are on a self-hosted runner.${getWorkflowEventName() !== "dynamic" ? ` To override this, set the ${envVar} environment variable to 'true' in your workflow. See ${"https://docs.github.com/en/actions/learn-github-actions/variables#defining-environment-variables-for-a-single-workflow" /* DEFINE_ENV_VARIABLES */} for more information.` : ""}`
       );
       core11.exportVariable(envVar, "false");
     } else {
-      logger.info(
+      logger2.info(
         `Enabling ${featureName}. This can be disabled by setting the ${envVar} environment variable to 'false'. See ${"https://docs.github.com/en/actions/learn-github-actions/variables#defining-environment-variables-for-a-single-workflow" /* DEFINE_ENV_VARIABLES */} for more information.`
       );
       core11.exportVariable(envVar, "true");
     }
   } else {
-    logger.info(`Disabling ${featureName}.`);
+    logger2.info(`Disabling ${featureName}.`);
     core11.exportVariable(envVar, "false");
   }
 }
-async function runAutobuild(config, language, logger) {
-  logger.startGroup(`Attempting to automatically build ${language} code`);
+async function runAutobuild(config, language, logger2) {
+  logger2.startGroup(`Attempting to automatically build ${language} code`);
   const codeQL = await getCodeQL(config.codeQLCmd);
   if (language === "cpp" /* cpp */) {
-    await setupCppAutobuild(codeQL, logger);
+    await setupCppAutobuild(codeQL, logger2);
   }
   if (config.buildMode) {
     await codeQL.extractUsingBuildMode(config, language);
@@ -154355,7 +154358,7 @@ async function runAutobuild(config, language, logger) {
   if (language === "go" /* go */) {
     core11.exportVariable("CODEQL_ACTION_DID_AUTOBUILD_GOLANG" /* DID_AUTOBUILD_GOLANG */, "true");
   }
-  logger.endGroup();
+  logger2.endGroup();
 }
 
 // src/dependency-caching.ts
@@ -154446,22 +154449,22 @@ var defaultCacheConfigs = {
 async function makeGlobber(patterns) {
   return glob.create(patterns.join("\n"));
 }
-async function checkHashPatterns(codeql, features, language, cacheConfig, checkType, logger) {
+async function checkHashPatterns(codeql, features, language, cacheConfig, checkType, logger2) {
   const patterns = await cacheConfig.getHashPatterns(codeql, features);
   if (patterns === void 0) {
-    logger.info(
+    logger2.info(
       `Skipping ${checkType} of dependency cache for ${language} as we cannot calculate a hash for the cache key.`
     );
   }
   return patterns;
 }
-async function downloadDependencyCaches(codeql, features, languages, logger) {
+async function downloadDependencyCaches(codeql, features, languages, logger2) {
   const status = [];
   const restoredKeys = [];
   for (const language of languages) {
     const cacheConfig = defaultCacheConfigs[language];
     if (cacheConfig === void 0) {
-      logger.info(
+      logger2.info(
         `Skipping download of dependency cache for ${language} as we have no caching configuration for it.`
       );
       continue;
@@ -154472,7 +154475,7 @@ async function downloadDependencyCaches(codeql, features, languages, logger) {
       language,
       cacheConfig,
       "download",
-      logger
+      logger2
     );
     if (patterns === void 0) {
       status.push({ language, hit_kind: "no-hash" /* NoHash */ });
@@ -154482,7 +154485,7 @@ async function downloadDependencyCaches(codeql, features, languages, logger) {
     const restoreKeys = [
       await cachePrefix2(codeql, features, language)
     ];
-    logger.info(
+    logger2.info(
       `Downloading cache for ${language} with key ${primaryKey} and restore keys ${restoreKeys.join(
         ", "
       )}`
@@ -154495,7 +154498,7 @@ async function downloadDependencyCaches(codeql, features, languages, logger) {
     );
     const download_duration_ms = Math.round(performance.now() - start);
     if (hitKey !== void 0) {
-      logger.info(`Cache hit on key ${hitKey} for ${language}.`);
+      logger2.info(`Cache hit on key ${hitKey} for ${language}.`);
       let hit_kind = "partial" /* Partial */;
       if (hitKey === primaryKey) {
         hit_kind = "exact" /* Exact */;
@@ -154508,17 +154511,17 @@ async function downloadDependencyCaches(codeql, features, languages, logger) {
       restoredKeys.push(hitKey);
     } else {
       status.push({ language, hit_kind: "miss" /* Miss */ });
-      logger.info(`No suitable cache found for ${language}.`);
+      logger2.info(`No suitable cache found for ${language}.`);
     }
   }
   return { statusReport: status, restoredKeys };
 }
-async function uploadDependencyCaches(codeql, features, config, logger) {
+async function uploadDependencyCaches(codeql, features, config, logger2) {
   const status = [];
   for (const language of config.languages) {
     const cacheConfig = defaultCacheConfigs[language];
     if (cacheConfig === void 0) {
-      logger.info(
+      logger2.info(
         `Skipping upload of dependency cache for ${language} as we have no caching configuration for it.`
       );
       continue;
@@ -154529,7 +154532,7 @@ async function uploadDependencyCaches(codeql, features, config, logger) {
       language,
       cacheConfig,
       "upload",
-      logger
+      logger2
     );
     if (patterns === void 0) {
       status.push({ language, result: "no-hash" /* NoHash */ });
@@ -154542,17 +154545,17 @@ async function uploadDependencyCaches(codeql, features, config, logger) {
     }
     const size = await getTotalCacheSize(
       await cacheConfig.getDependencyPaths(codeql, features),
-      logger,
+      logger2,
       true
     );
     if (size === 0) {
       status.push({ language, result: "empty" /* Empty */ });
-      logger.info(
+      logger2.info(
         `Skipping upload of dependency cache for ${language} since it is empty.`
       );
       continue;
     }
-    logger.info(
+    logger2.info(
       `Uploading cache of size ${size} for ${language} with key ${key}...`
     );
     try {
@@ -154570,10 +154573,10 @@ async function uploadDependencyCaches(codeql, features, config, logger) {
       });
     } catch (error3) {
       if (error3 instanceof actionsCache4.ReserveCacheError) {
-        logger.info(
+        logger2.info(
           `Not uploading cache for ${language}, because ${key} is already in use.`
         );
-        logger.debug(error3.message);
+        logger2.debug(error3.message);
         status.push({ language, result: "duplicate" /* Duplicate */ });
       } else {
         throw error3;
@@ -154612,7 +154615,7 @@ async function cachePrefix2(codeql, features, language) {
   const featurePrefix = await getFeaturePrefix(codeql, features, language);
   return `${prefix}-${featurePrefix}${CODEQL_DEPENDENCY_CACHE_VERSION}-${runnerOs}-${language}-`;
 }
-async function getDependencyCacheUsage(logger) {
+async function getDependencyCacheUsage(logger2) {
   try {
     const caches = await listActionsCaches(CODEQL_DEPENDENCY_CACHE_PREFIX);
     const totalSize = caches.reduce(
@@ -154621,7 +154624,7 @@ async function getDependencyCacheUsage(logger) {
     );
     return { count: caches.length, size_bytes: totalSize };
   } catch (err) {
-    logger.warning(
+    logger2.warning(
       `Unable to retrieve information about dependency cache usage: ${getErrorMessage(err)}`
     );
   }
@@ -154644,32 +154647,32 @@ var CodeQLAnalysisError = class extends Error {
   message;
   error;
 };
-async function setupPythonExtractor(logger) {
+async function setupPythonExtractor(logger2) {
   const codeqlPython = process.env["CODEQL_PYTHON"];
   if (codeqlPython === void 0 || codeqlPython.length === 0) {
     return;
   }
-  logger.warning(
+  logger2.warning(
     "The CODEQL_PYTHON environment variable is no longer supported. Please remove it from your workflow. This environment variable was originally used to specify a Python executable that included the dependencies of your Python code, however Python analysis no longer uses these dependencies.\nIf you used CODEQL_PYTHON to force the version of Python to analyze as, please use CODEQL_EXTRACTOR_PYTHON_ANALYSIS_VERSION instead, such as 'CODEQL_EXTRACTOR_PYTHON_ANALYSIS_VERSION=2.7' or 'CODEQL_EXTRACTOR_PYTHON_ANALYSIS_VERSION=3.11'."
   );
   return;
 }
-async function runExtraction(codeql, features, config, logger) {
+async function runExtraction(codeql, features, config, logger2) {
   for (const language of config.languages) {
-    if (dbIsFinalized(config, language, logger)) {
-      logger.debug(
+    if (dbIsFinalized(config, language, logger2)) {
+      logger2.debug(
         `Database for ${language} has already been finalized, skipping extraction.`
       );
       continue;
     }
     if (await shouldExtractLanguage(codeql, config, language)) {
-      logger.startGroup(`Extracting ${language}`);
+      logger2.startGroup(`Extracting ${language}`);
       if (language === "python" /* python */) {
-        await setupPythonExtractor(logger);
+        await setupPythonExtractor(logger2);
       }
       if (config.buildMode) {
         if (language === "cpp" /* cpp */ && config.buildMode === "autobuild" /* Autobuild */) {
-          await setupCppAutobuild(codeql, logger);
+          await setupCppAutobuild(codeql, logger2);
         }
         if (language === "java" /* java */ && config.buildMode === "none" /* None */) {
           process.env["CODEQL_EXTRACTOR_JAVA_OPTION_BUILDLESS_DEPENDENCY_DIR"] = getJavaTempDependencyDir();
@@ -154681,14 +154684,14 @@ async function runExtraction(codeql, features, config, logger) {
       } else {
         await codeql.extractScannedLanguage(config, language);
       }
-      logger.endGroup();
+      logger2.endGroup();
     }
   }
 }
 async function shouldExtractLanguage(codeql, config, language) {
   return config.buildMode === "none" /* None */ || config.buildMode === "autobuild" /* Autobuild */ && process.env["CODEQL_ACTION_AUTOBUILD_DID_COMPLETE_SUCCESSFULLY" /* AUTOBUILD_DID_COMPLETE_SUCCESSFULLY */] !== "true" || !config.buildMode && await codeql.isScannedLanguage(language);
 }
-function dbIsFinalized(config, language, logger) {
+function dbIsFinalized(config, language, logger2) {
   const dbPath = getCodeQLDatabasePath(config, language);
   try {
     const dbInfo = load(
@@ -154696,31 +154699,31 @@ function dbIsFinalized(config, language, logger) {
     );
     return !("inProgress" in dbInfo);
   } catch {
-    logger.warning(
+    logger2.warning(
       `Could not check whether database for ${language} was finalized. Assuming it is not.`
     );
     return false;
   }
 }
-async function finalizeDatabaseCreation(codeql, features, config, threadsFlag, memoryFlag, logger) {
+async function finalizeDatabaseCreation(codeql, features, config, threadsFlag, memoryFlag, logger2) {
   const extractionStart = import_perf_hooks3.performance.now();
-  await runExtraction(codeql, features, config, logger);
+  await runExtraction(codeql, features, config, logger2);
   const extractionTime = import_perf_hooks3.performance.now() - extractionStart;
   const trapImportStart = import_perf_hooks3.performance.now();
   for (const language of config.languages) {
-    if (dbIsFinalized(config, language, logger)) {
-      logger.info(
+    if (dbIsFinalized(config, language, logger2)) {
+      logger2.info(
         `There is already a finalized database for ${language} at the location where the CodeQL Action places databases, so we did not create one.`
       );
     } else {
-      logger.startGroup(`Finalizing ${language}`);
+      logger2.startGroup(`Finalizing ${language}`);
       await codeql.finalizeDatabase(
         getCodeQLDatabasePath(config, language),
         threadsFlag,
         memoryFlag,
         config.debugMode
       );
-      logger.endGroup();
+      logger2.endGroup();
     }
   }
   const trapImportTime = import_perf_hooks3.performance.now() - trapImportStart;
@@ -154729,24 +154732,24 @@ async function finalizeDatabaseCreation(codeql, features, config, threadsFlag, m
     trap_import_duration_ms: Math.round(trapImportTime)
   };
 }
-async function setupDiffInformedQueryRun(logger) {
+async function setupDiffInformedQueryRun(logger2) {
   return await withGroupAsync(
     "Generating diff range extension pack",
     async () => {
-      const diffRanges = readDiffRangesJsonFile(logger);
+      const diffRanges = readDiffRangesJsonFile(logger2);
       if (diffRanges === void 0) {
-        logger.info(
+        logger2.info(
           "No precomputed diff ranges found; skipping diff-informed analysis stage."
         );
         return void 0;
       }
       const checkoutPath = getRequiredInput("checkout_path");
       const packDir = writeDiffRangeDataExtensionPack(
-        logger,
+        logger2,
         diffRanges,
         checkoutPath
       );
-      logger.info(
+      logger2.info(
         `Successfully created diff range extension pack at ${packDir}.`
       );
       return packDir;
@@ -154772,7 +154775,7 @@ extensions:
   }
   return header + data;
 }
-function writeDiffRangeDataExtensionPack(logger, ranges, checkoutPath) {
+function writeDiffRangeDataExtensionPack(logger2, ranges, checkoutPath) {
   if (ranges.length === 0) {
     ranges = [{ path: "", startLine: 0, endLine: 0 }];
   }
@@ -154796,7 +154799,7 @@ dataExtensions:
   );
   const extensionFilePath = path16.join(diffRangeDir, "pr-diff-range.yml");
   fs17.writeFileSync(extensionFilePath, extensionContents);
-  logger.debug(
+  logger2.debug(
     `Wrote pr-diff-range extension pack to ${extensionFilePath}:
 ${extensionContents}`
   );
@@ -154818,7 +154821,7 @@ function resolveQuerySuiteAlias(language, maybeSuite) {
 function addSarifExtension(analysis, base) {
   return `${base}${analysis.sarifExtension}`;
 }
-async function runQueries(sarifFolder, memoryFlag, threadsFlag, diffRangePackDir, automationDetailsId, codeql, config, logger, features) {
+async function runQueries(sarifFolder, memoryFlag, threadsFlag, diffRangePackDir, automationDetailsId, codeql, config, logger2, features) {
   const statusReport = {};
   const queryFlags = [memoryFlag, threadsFlag];
   const incrementalMode = [];
@@ -154849,11 +154852,11 @@ async function runQueries(sarifFolder, memoryFlag, threadsFlag, diffRangePackDir
           }
         }
       }
-      logger.startGroup(`Running queries for ${language}`);
+      logger2.startGroup(`Running queries for ${language}`);
       const startTimeRunQueries = (/* @__PURE__ */ new Date()).getTime();
       const databasePath = getCodeQLDatabasePath(config, language);
       await codeql.databaseRunQueries(databasePath, queryFlags, queries);
-      logger.debug(`Finished running queries for ${language}.`);
+      logger2.debug(`Finished running queries for ${language}.`);
       statusReport[`analyze_builtin_queries_${language}_duration_ms`] = (/* @__PURE__ */ new Date()).getTime() - startTimeRunQueries;
       const startTimeInterpretResults = /* @__PURE__ */ new Date();
       const { summary: analysisSummary, sarifFile } = await runInterpretResultsFor(
@@ -154876,15 +154879,15 @@ async function runQueries(sarifFolder, memoryFlag, threadsFlag, diffRangePackDir
       }
       const endTimeInterpretResults = /* @__PURE__ */ new Date();
       statusReport[`interpret_results_${language}_duration_ms`] = endTimeInterpretResults.getTime() - startTimeInterpretResults.getTime();
-      logger.endGroup();
+      logger2.endGroup();
       if (analysisSummary.trim()) {
-        logger.info(analysisSummary);
+        logger2.info(analysisSummary);
       }
       if (qualityAnalysisSummary?.trim()) {
-        logger.info(qualityAnalysisSummary);
+        logger2.info(qualityAnalysisSummary);
       }
       if (!config.enableFileCoverageInformation) {
-        logger.info(
+        logger2.info(
           "To speed up pull request analysis, file coverage information is only enabled when analyzing the default branch and protected branches."
         );
       }
@@ -154916,8 +154919,8 @@ async function runQueries(sarifFolder, memoryFlag, threadsFlag, diffRangePackDir
   }
   return statusReport;
   async function runInterpretResultsFor(analysis, language, queries, enableDebugLogging) {
-    logger.info(`Interpreting ${analysis.name} results for ${language}`);
-    const category = analysis.fixCategory(logger, automationDetailsId);
+    logger2.info(`Interpreting ${analysis.name} results for ${language}`);
+    const category = analysis.fixCategory(logger2, automationDetailsId);
     const sarifFile = path16.join(
       sarifFolder,
       addSarifExtension(analysis, language)
@@ -154963,7 +154966,7 @@ async function runQueries(sarifFolder, memoryFlag, threadsFlag, diffRangePackDir
     return perQueryAlertCounts;
   }
 }
-async function runFinalize(features, outputDir, threadsFlag, memoryFlag, codeql, config, logger) {
+async function runFinalize(features, outputDir, threadsFlag, memoryFlag, codeql, config, logger2) {
   try {
     await fs17.promises.rm(outputDir, { force: true, recursive: true });
   } catch (error3) {
@@ -154978,19 +154981,19 @@ async function runFinalize(features, outputDir, threadsFlag, memoryFlag, codeql,
     config,
     threadsFlag,
     memoryFlag,
-    logger
+    logger2
   );
   if (process.env["CODEQL_ACTION_AUTOBUILD_DID_COMPLETE_SUCCESSFULLY" /* AUTOBUILD_DID_COMPLETE_SUCCESSFULLY */] !== "true") {
-    await endTracingForCluster(codeql, config, logger);
+    await endTracingForCluster(codeql, config, logger2);
   }
   return timings;
 }
-async function warnIfGoInstalledAfterInit(config, logger) {
+async function warnIfGoInstalledAfterInit(config, logger2) {
   const goInitPath = process.env["CODEQL_ACTION_GO_BINARY" /* GO_BINARY_LOCATION */];
   if (process.env["CODEQL_ACTION_DID_AUTOBUILD_GOLANG" /* DID_AUTOBUILD_GOLANG */] !== "true" && goInitPath !== void 0) {
     const goBinaryPath = await io5.which("go", true);
     if (goInitPath !== goBinaryPath) {
-      logger.warning(
+      logger2.warning(
         `Expected \`which go\` to return ${goInitPath}, but got ${goBinaryPath}: please ensure that the correct version of Go is installed before the \`codeql-action/init\` Action is used.`
       );
       addDiagnostic(
@@ -155016,27 +155019,27 @@ async function warnIfGoInstalledAfterInit(config, logger) {
 
 // src/database-upload.ts
 var fs18 = __toESM(require("fs"));
-async function cleanupAndUploadDatabases(repositoryNwo, codeql, config, apiDetails, features, logger) {
+async function cleanupAndUploadDatabases(repositoryNwo, codeql, config, apiDetails, features, logger2) {
   if (getRequiredInput("upload-database") !== "true") {
-    logger.debug("Database upload disabled in workflow. Skipping upload.");
+    logger2.debug("Database upload disabled in workflow. Skipping upload.");
     return [];
   }
   if (!config.analysisKinds.includes("code-scanning" /* CodeScanning */)) {
-    logger.debug(
+    logger2.debug(
       `Not uploading database because 'analysis-kinds: ${"code-scanning" /* CodeScanning */}' is not enabled.`
     );
     return [];
   }
   if (isInTestMode()) {
-    logger.debug("In test mode. Skipping database upload.");
+    logger2.debug("In test mode. Skipping database upload.");
     return [];
   }
   if (config.gitHubVersion.type !== "GitHub.com" /* DOTCOM */ && config.gitHubVersion.type !== "GitHub Enterprise Cloud with data residency" /* GHEC_DR */) {
-    logger.debug("Not running against github.com or GHEC-DR. Skipping upload.");
+    logger2.debug("Not running against github.com or GHEC-DR. Skipping upload.");
     return [];
   }
   if (!await isAnalyzingDefaultBranch()) {
-    logger.debug("Not analyzing default branch. Skipping upload.");
+    logger2.debug("Not analyzing default branch. Skipping upload.");
     return [];
   }
   const shouldUploadOverlayBase = config.overlayDatabaseMode === "overlay-base" /* OverlayBase */ && await features.getValue("upload_overlay_db_to_api" /* UploadOverlayDbToApi */, codeql);
@@ -155074,13 +155077,13 @@ async function cleanupAndUploadDatabases(repositoryNwo, codeql, config, apiDetai
           if (!isRetryable) {
             throw e;
           } else if (attempt === maxAttempts) {
-            logger.error(
+            logger2.error(
               `Maximum retry attempts exhausted (${attempt}), aborting database upload`
             );
             throw e;
           }
           const backoffMs = 15e3 * Math.pow(2, attempt - 1);
-          logger.debug(
+          logger2.debug(
             `Database upload attempt ${attempt} of ${maxAttempts} failed for ${language}: ${getErrorMessage(e)}. Retrying in ${backoffMs / 1e3}s...`
           );
           await new Promise((resolve13) => setTimeout(resolve13, backoffMs));
@@ -155092,9 +155095,9 @@ async function cleanupAndUploadDatabases(repositoryNwo, codeql, config, apiDetai
         is_overlay_base: shouldUploadOverlayBase,
         upload_duration_ms: uploadDurationMs
       });
-      logger.debug(`Successfully uploaded database for ${language}`);
+      logger2.debug(`Successfully uploaded database for ${language}`);
     } catch (e) {
-      logger.warning(
+      logger2.warning(
         `Failed to upload database for ${language}: ${getErrorMessage(e)}`
       );
       reports.push({
@@ -155197,7 +155200,7 @@ function setJobStatusIfUnsuccessful(actionStatus) {
     );
   }
 }
-async function createStatusReportBase(actionName, status, actionStartedAt, config, diskInfo, logger, cause, exception) {
+async function createStatusReportBase(actionName, status, actionStartedAt, config, diskInfo, logger2, cause, exception) {
   try {
     const commitOid = getOptionalInput("sha") || process.env["GITHUB_SHA"] || "";
     const ref = await getRef();
@@ -155251,7 +155254,7 @@ async function createStatusReportBase(actionName, status, actionStartedAt, confi
     try {
       statusReport.actions_event_name = getWorkflowEventName();
     } catch (e) {
-      logger.warning(
+      logger2.warning(
         `Could not determine the workflow event name: ${getErrorMessage(e)}.`
       );
     }
@@ -155290,7 +155293,7 @@ async function createStatusReportBase(actionName, status, actionStartedAt, confi
     }
     return statusReport;
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to gather information for telemetry: ${getErrorMessage(e)}. Will skip sending status report.`
     );
     if (isInTestMode()) {
@@ -155400,7 +155403,7 @@ async function createInitWithConfigStatusReport(config, initStatusReport, config
     )
   };
 }
-async function sendUnhandledErrorStatusReport(actionName, actionStartedAt, error3, logger) {
+async function sendUnhandledErrorStatusReport(actionName, actionStartedAt, error3, logger2) {
   try {
     const statusReport = await createStatusReportBase(
       actionName,
@@ -155408,7 +155411,7 @@ async function sendUnhandledErrorStatusReport(actionName, actionStartedAt, error
       actionStartedAt,
       void 0,
       void 0,
-      logger,
+      logger2,
       `Unhandled CodeQL Action error: ${getErrorMessage(error3)}`,
       error3 instanceof Error ? error3.stack : void 0
     );
@@ -155416,7 +155419,7 @@ async function sendUnhandledErrorStatusReport(actionName, actionStartedAt, error
       await sendStatusReport(statusReport);
     }
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to send the unhandled error status report: ${getErrorMessage(e)}.`
     );
     if (isInTestMode()) {
@@ -156457,7 +156460,7 @@ async function hash(callback, filepath) {
     updateHash(0);
   }
 }
-function locationUpdateCallback(result, location, logger) {
+function locationUpdateCallback(result, location, logger2) {
   let locationStartLine = location.physicalLocation?.region?.startLine;
   if (locationStartLine === void 0) {
     locationStartLine = 1;
@@ -156473,29 +156476,29 @@ function locationUpdateCallback(result, location, logger) {
     if (!existingFingerprint) {
       result.partialFingerprints.primaryLocationLineHash = hashValue;
     } else if (existingFingerprint !== hashValue) {
-      logger.warning(
+      logger2.warning(
         `Calculated fingerprint of ${hashValue} for file ${location.physicalLocation.artifactLocation.uri} line ${lineNumber}, but found existing inconsistent fingerprint value ${existingFingerprint}`
       );
     }
   };
 }
-function resolveUriToFile(location, artifacts, sourceRoot, logger) {
+function resolveUriToFile(location, artifacts, sourceRoot, logger2) {
   if (!location.uri && location.index !== void 0) {
     if (typeof location.index !== "number" || location.index < 0 || location.index >= artifacts.length || !isObject(artifacts[location.index].location)) {
-      logger.debug(`Ignoring location as index "${location.index}" is invalid`);
+      logger2.debug(`Ignoring location as index "${location.index}" is invalid`);
       return void 0;
     }
     location = artifacts[location.index].location;
   }
   if (typeof location.uri !== "string") {
-    logger.debug(`Ignoring location as URI "${location.uri}" is invalid`);
+    logger2.debug(`Ignoring location as URI "${location.uri}" is invalid`);
     return void 0;
   }
   let uri;
   try {
     uri = decodeURIComponent(location.uri);
   } catch {
-    logger.debug(`Ignoring location as URI "${location.uri}" is invalid`);
+    logger2.debug(`Ignoring location as URI "${location.uri}" is invalid`);
     return void 0;
   }
   const fileUriPrefix = "file://";
@@ -156503,14 +156506,14 @@ function resolveUriToFile(location, artifacts, sourceRoot, logger) {
     uri = uri.substring(fileUriPrefix.length);
   }
   if (uri.indexOf("://") !== -1) {
-    logger.debug(
+    logger2.debug(
       `Ignoring location URI "${uri}" as the scheme is not recognised`
     );
     return void 0;
   }
   const srcRootPrefix = `${sourceRoot}/`;
   if (uri.startsWith("/") && !uri.startsWith(srcRootPrefix)) {
-    logger.debug(
+    logger2.debug(
       `Ignoring location URI "${uri}" as it is outside of the src root`
     );
     return void 0;
@@ -156519,17 +156522,17 @@ function resolveUriToFile(location, artifacts, sourceRoot, logger) {
     uri = srcRootPrefix + uri;
   }
   if (!fs19.existsSync(uri)) {
-    logger.debug(`Unable to compute fingerprint for non-existent file: ${uri}`);
+    logger2.debug(`Unable to compute fingerprint for non-existent file: ${uri}`);
     return void 0;
   }
   if (fs19.statSync(uri).isDirectory()) {
-    logger.debug(`Unable to compute fingerprint for directory: ${uri}`);
+    logger2.debug(`Unable to compute fingerprint for directory: ${uri}`);
     return void 0;
   }
   return uri;
 }
-async function addFingerprints(sarifLog, sourceRoot, logger) {
-  logger.info(
+async function addFingerprints(sarifLog, sourceRoot, logger2) {
+  logger2.info(
     `Adding fingerprints to SARIF file. See ${"https://docs.github.com/en/code-security/reference/code-scanning/sarif-support-for-code-scanning#data-for-preventing-duplicated-alerts" /* TRACK_CODE_SCANNING_ALERTS_ACROSS_RUNS */} for more information.`
   );
   const callbacksByFile = {};
@@ -156538,7 +156541,7 @@ async function addFingerprints(sarifLog, sourceRoot, logger) {
     for (const result of run9.results || []) {
       const primaryLocation = (result.locations || [])[0];
       if (!primaryLocation?.physicalLocation?.artifactLocation) {
-        logger.debug(
+        logger2.debug(
           `Unable to compute fingerprint for invalid location: ${JSON.stringify(
             primaryLocation
           )}`
@@ -156552,7 +156555,7 @@ async function addFingerprints(sarifLog, sourceRoot, logger) {
         primaryLocation.physicalLocation.artifactLocation,
         artifacts,
         sourceRoot,
-        logger
+        logger2
       );
       if (!filepath) {
         continue;
@@ -156561,7 +156564,7 @@ async function addFingerprints(sarifLog, sourceRoot, logger) {
         callbacksByFile[filepath] = [];
       }
       callbacksByFile[filepath].push(
-        locationUpdateCallback(result, primaryLocation, logger)
+        locationUpdateCallback(result, primaryLocation, logger2)
       );
     }
   }
@@ -156583,8 +156586,8 @@ var core13 = __toESM(require_core());
 var toolrunner4 = __toESM(require_toolrunner());
 var github2 = __toESM(require_github());
 var io6 = __toESM(require_io());
-async function initCodeQL(toolsInput, apiDetails, tempDir, variant, defaultCliVersion, rawLanguages, useOverlayAwareDefaultCliVersion, features, logger) {
-  logger.startGroup("Setup CodeQL tools");
+async function initCodeQL(toolsInput, apiDetails, tempDir, variant, defaultCliVersion, rawLanguages, useOverlayAwareDefaultCliVersion, features, logger2) {
+  logger2.startGroup("Setup CodeQL tools");
   const {
     codeql,
     toolsDownloadStatusReport,
@@ -156600,11 +156603,11 @@ async function initCodeQL(toolsInput, apiDetails, tempDir, variant, defaultCliVe
     rawLanguages,
     useOverlayAwareDefaultCliVersion,
     features,
-    logger,
+    logger2,
     true
   );
   await codeql.printVersion();
-  logger.endGroup();
+  logger2.endGroup();
   return {
     codeql,
     toolsDownloadStatusReport,
@@ -156618,7 +156621,7 @@ async function initConfig2(features, inputs) {
     return await initConfig(features, inputs);
   });
 }
-async function runDatabaseInitCluster(databaseInitEnvironment, codeql, config, sourceRoot, processName, qlconfigFile, logger) {
+async function runDatabaseInitCluster(databaseInitEnvironment, codeql, config, sourceRoot, processName, qlconfigFile, logger2) {
   fs20.mkdirSync(config.dbLocation, { recursive: true });
   await wrapEnvironment(
     databaseInitEnvironment,
@@ -156627,14 +156630,14 @@ async function runDatabaseInitCluster(databaseInitEnvironment, codeql, config, s
       sourceRoot,
       processName,
       qlconfigFile,
-      logger
+      logger2
     )
   );
 }
-async function checkPacksForOverlayCompatibility(codeql, config, logger) {
+async function checkPacksForOverlayCompatibility(codeql, config, logger2) {
   const codeQlOverlayVersion = (await codeql.getVersion()).overlayVersion;
   if (codeQlOverlayVersion === void 0) {
-    logger.warning("The CodeQL CLI does not support overlay analysis.");
+    logger2.warning("The CodeQL CLI does not support overlay analysis.");
     return false;
   }
   for (const language of config.languages) {
@@ -156644,7 +156647,7 @@ async function checkPacksForOverlayCompatibility(codeql, config, logger) {
       (packDir) => !checkPackForOverlayCompatibility(
         packDir,
         codeQlOverlayVersion,
-        logger
+        logger2
       )
     )) {
       return false;
@@ -156652,7 +156655,7 @@ async function checkPacksForOverlayCompatibility(codeql, config, logger) {
   }
   return true;
 }
-function checkPackForOverlayCompatibility(packDir, codeQlOverlayVersion, logger) {
+function checkPackForOverlayCompatibility(packDir, codeQlOverlayVersion, logger2) {
   try {
     let qlpackPath = path18.join(packDir, "qlpack.yml");
     if (!fs20.existsSync(qlpackPath)) {
@@ -156666,7 +156669,7 @@ function checkPackForOverlayCompatibility(packDir, codeQlOverlayVersion, logger)
     }
     const packInfoPath = path18.join(packDir, ".packinfo");
     if (!fs20.existsSync(packInfoPath)) {
-      logger.warning(
+      logger2.warning(
         `The query pack at ${packDir} does not have a .packinfo file, so it cannot support overlay analysis. Recompiling the query pack with the latest CodeQL CLI should solve this problem.`
       );
       return false;
@@ -156676,19 +156679,19 @@ function checkPackForOverlayCompatibility(packDir, codeQlOverlayVersion, logger)
     );
     const packOverlayVersion = packInfoFileContents.overlayVersion;
     if (typeof packOverlayVersion !== "number") {
-      logger.warning(
+      logger2.warning(
         `The .packinfo file for the query pack at ${packDir} does not have the overlayVersion field, which indicates that the pack is not compatible with overlay analysis.`
       );
       return false;
     }
     if (packOverlayVersion !== codeQlOverlayVersion) {
-      logger.warning(
+      logger2.warning(
         `The query pack at ${packDir} was compiled with overlay version ${packOverlayVersion}, but the CodeQL CLI supports overlay version ${codeQlOverlayVersion}. The query pack needs to be recompiled to support overlay analysis.`
       );
       return false;
     }
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Error while checking pack at ${packDir} for overlay compatibility: ${getErrorMessage(e)}`
     );
     return false;
@@ -156707,10 +156710,10 @@ async function checkInstallPython311(languages, codeql) {
     ]).exec();
   }
 }
-function cleanupDatabaseClusterDirectory(config, logger, options = {}, rmSync5 = fs20.rmSync) {
+function cleanupDatabaseClusterDirectory(config, logger2, options = {}, rmSync5 = fs20.rmSync) {
   if (fs20.existsSync(config.dbLocation) && (fs20.statSync(config.dbLocation).isFile() || fs20.readdirSync(config.dbLocation).length > 0)) {
     if (!options.disableExistingDirectoryWarning) {
-      logger.warning(
+      logger2.warning(
         `The database cluster directory ${config.dbLocation} must be empty. Attempting to clean it up.`
       );
     }
@@ -156720,7 +156723,7 @@ function cleanupDatabaseClusterDirectory(config, logger, options = {}, rmSync5 =
         maxRetries: 3,
         recursive: true
       });
-      logger.info(
+      logger2.info(
         `Cleaned up database cluster directory ${config.dbLocation}.`
       );
     } catch (e) {
@@ -156781,7 +156784,7 @@ async function getFileCoverageInformationEnabled(debugMode, codeql, features, re
     showDeprecationWarning: false
   };
 }
-function logFileCoverageOnPrsDeprecationWarning(logger) {
+function logFileCoverageOnPrsDeprecationWarning(logger2) {
   if (process.env["CODEQL_ACTION_DID_LOG_FILE_COVERAGE_ON_PRS_DEPRECATION" /* DID_LOG_FILE_COVERAGE_ON_PRS_DEPRECATION */]) {
     return;
   }
@@ -156808,7 +156811,7 @@ To opt out of this change, switch to an advanced setup workflow and ${envVarOptO
 
 To opt out of this change, ${envVarOptOut}`;
   }
-  logger.warning(message);
+  logger2.warning(message);
   core13.exportVariable("CODEQL_ACTION_DID_LOG_FILE_COVERAGE_ON_PRS_DEPRECATION" /* DID_LOG_FILE_COVERAGE_ON_PRS_DEPRECATION */, "true");
 }
 
@@ -156830,12 +156833,12 @@ function getToolNames(sarifFile) {
 function readSarifFile(sarifFilePath) {
   return JSON.parse(fs21.readFileSync(sarifFilePath, "utf8"));
 }
-function combineSarifFiles(sarifFiles, logger) {
-  logger.info(`Loading SARIF file(s)`);
+function combineSarifFiles(sarifFiles, logger2) {
+  logger2.info(`Loading SARIF file(s)`);
   const runs = [];
   let version = void 0;
   for (const sarifFile of sarifFiles) {
-    logger.debug(`Loading SARIF file: ${sarifFile}`);
+    logger2.debug(`Loading SARIF file: ${sarifFile}`);
     const sarifLog = readSarifFile(sarifFile);
     if (version === void 0) {
       version = sarifLog.version;
@@ -156909,32 +156912,32 @@ async function shouldDisableCombineSarifFiles(sarifObjects, githubVersion) {
   }
   return true;
 }
-async function combineSarifFilesUsingCLI(sarifFiles, gitHubVersion, features, logger) {
-  logger.info("Combining SARIF files using the CodeQL CLI");
+async function combineSarifFilesUsingCLI(sarifFiles, gitHubVersion, features, logger2) {
+  logger2.info("Combining SARIF files using the CodeQL CLI");
   const sarifObjects = sarifFiles.map(readSarifFile);
   const deprecationWarningMessage = gitHubVersion.type === "GitHub Enterprise Server" /* GHES */ ? "and will be removed in GitHub Enterprise Server 3.18" : "and will be removed in July 2025";
   const deprecationMoreInformationMessage = "For more information, see https://github.blog/changelog/2024-05-06-code-scanning-will-stop-combining-runs-from-a-single-upload";
   if (!areAllRunsProducedByCodeQL(sarifObjects)) {
     await throwIfCombineSarifFilesDisabled(sarifObjects, gitHubVersion);
-    logger.debug(
+    logger2.debug(
       "Not all SARIF files were produced by CodeQL. Merging files in the action."
     );
     if (await shouldShowCombineSarifFilesDeprecationWarning(sarifObjects)) {
-      logger.warning(
+      logger2.warning(
         `Uploading multiple SARIF runs with the same category is deprecated ${deprecationWarningMessage}. Please update your workflow to upload a single run per category. ${deprecationMoreInformationMessage}`
       );
       core14.exportVariable("CODEQL_MERGE_SARIF_DEPRECATION_WARNING", "true");
     }
-    return combineSarifFiles(sarifFiles, logger);
+    return combineSarifFiles(sarifFiles, logger2);
   }
   let codeQL;
   let tempDir = getTemporaryDirectory();
-  const config = await getConfig(tempDir, logger);
+  const config = await getConfig(tempDir, logger2);
   if (config !== void 0) {
     codeQL = await getCodeQL(config.codeQLCmd);
     tempDir = config.tempDir;
   } else {
-    logger.info(
+    logger2.info(
       "Initializing CodeQL since the 'init' Action was not called before this step."
     );
     const apiDetails = {
@@ -156958,7 +156961,7 @@ async function combineSarifFilesUsingCLI(sarifFiles, gitHubVersion, features, lo
       false,
       // useOverlayAwareDefaultCliVersion: upload-lib does not run analysis
       features,
-      logger
+      logger2
     );
     codeQL = initCodeQLResult.codeql;
   }
@@ -156995,17 +156998,17 @@ function getAutomationID2(category, analysis_key, environment) {
   }
   return computeAutomationID(analysis_key, environment);
 }
-async function uploadPayload(payload, repositoryNwo, logger, analysis) {
-  logger.info("Uploading results");
+async function uploadPayload(payload, repositoryNwo, logger2, analysis) {
+  logger2.info("Uploading results");
   if (shouldSkipSarifUpload()) {
     const payloadSaveFile = path19.join(
       getTemporaryDirectory(),
       `payload-${analysis.kind}.json`
     );
-    logger.info(
+    logger2.info(
       `SARIF upload disabled by an environment variable. Saving to ${payloadSaveFile}`
     );
-    logger.info(`Payload: ${JSON.stringify(payload, null, 2)}`);
+    logger2.info(`Payload: ${JSON.stringify(payload, null, 2)}`);
     fs22.writeFileSync(payloadSaveFile, JSON.stringify(payload, null, 2));
     return "dummy-sarif-id";
   }
@@ -157016,8 +157019,8 @@ async function uploadPayload(payload, repositoryNwo, logger, analysis) {
       repo: repositoryNwo.repo,
       data: payload
     });
-    logger.debug(`response status: ${response.status}`);
-    logger.info("Successfully uploaded results");
+    logger2.debug(`response status: ${response.status}`);
+    logger2.info("Successfully uploaded results");
     return response.data.id;
   } catch (e) {
     const httpError = asHTTPError(e);
@@ -157069,7 +157072,7 @@ function getSarifFilePaths(sarifPath, isSarif) {
   }
   return sarifFiles;
 }
-async function getGroupedSarifFilePaths(logger, sarifPath) {
+async function getGroupedSarifFilePaths(logger2, sarifPath) {
   const stats = fs22.statSync(sarifPath, { throwIfNoEntry: false });
   if (stats === void 0) {
     throw new ConfigurationError(`Path does not exist: ${sarifPath}`);
@@ -157080,7 +157083,7 @@ async function getGroupedSarifFilePaths(logger, sarifPath) {
       sarifPath,
       (name) => path19.extname(name) === ".sarif"
     );
-    logger.debug(
+    logger2.debug(
       `Found the following .sarif files in ${sarifPath}: ${unassignedSarifFiles.join(", ")}`
     );
     for (const analysisConfig of SarifScanOrder) {
@@ -157088,7 +157091,7 @@ async function getGroupedSarifFilePaths(logger, sarifPath) {
         analysisConfig.sarifPredicate
       );
       if (filesForCurrentAnalysis.length > 0) {
-        logger.debug(
+        logger2.debug(
           `The following SARIF files are for ${analysisConfig.name}: ${filesForCurrentAnalysis.join(", ")}`
         );
         unassignedSarifFiles = unassignedSarifFiles.filter(
@@ -157096,18 +157099,18 @@ async function getGroupedSarifFilePaths(logger, sarifPath) {
         );
         results[analysisConfig.kind] = filesForCurrentAnalysis;
       } else {
-        logger.debug(`Found no SARIF files for ${analysisConfig.name}`);
+        logger2.debug(`Found no SARIF files for ${analysisConfig.name}`);
       }
     }
     if (unassignedSarifFiles.length !== 0) {
-      logger.warning(
+      logger2.warning(
         `Found files in ${sarifPath} which do not belong to any analysis: ${unassignedSarifFiles.join(", ")}`
       );
     }
   } else {
     for (const analysisConfig of SarifScanOrder) {
       if (analysisConfig.kind === "code-scanning" /* CodeScanning */ || analysisConfig.sarifPredicate(sarifPath)) {
-        logger.debug(
+        logger2.debug(
           `Using '${sarifPath}' as a SARIF file for ${analysisConfig.name}.`
         );
         results[analysisConfig.kind] = [sarifPath];
@@ -157142,15 +157145,15 @@ function readSarifFileOrThrow(sarifFilePath) {
     );
   }
 }
-function validateSarifFileSchema(sarifLog, sarifFilePath, logger) {
+function validateSarifFileSchema(sarifLog, sarifFilePath, logger2) {
   if (areAllRunsProducedByCodeQL([sarifLog]) && // We want to validate CodeQL SARIF in testing environments.
   !getTestingEnvironment()) {
-    logger.debug(
+    logger2.debug(
       `Skipping SARIF schema validation for ${sarifFilePath} as all runs are produced by CodeQL.`
     );
     return true;
   }
-  logger.info(`Validating ${sarifFilePath}`);
+  logger2.info(`Validating ${sarifFilePath}`);
   const schema = require_sarif_schema_2_1_0();
   const result = new jsonschema2.Validator().validate(sarifLog, schema);
   const warningAttributes = ["uri-reference", "uri"];
@@ -157161,15 +157164,15 @@ function validateSarifFileSchema(sarifLog, sarifFilePath, logger) {
     (err) => err.name === "format" && typeof err.argument === "string" && warningAttributes.includes(err.argument)
   );
   for (const warning14 of warnings) {
-    logger.info(
+    logger2.info(
       `Warning: '${warning14.instance}' is not a valid URI in '${warning14.property}'.`
     );
   }
   if (errors.length > 0) {
     for (const error3 of errors) {
-      logger.startGroup(`Error details: ${error3.stack}`);
-      logger.info(JSON.stringify(error3, null, 2));
-      logger.endGroup();
+      logger2.startGroup(`Error details: ${error3.stack}`);
+      logger2.info(JSON.stringify(error3, null, 2));
+      logger2.endGroup();
     }
     const sarifErrors = errors.map((e) => `- ${e.stack}`);
     throw new InvalidSarifUploadError(
@@ -157213,30 +157216,30 @@ function buildPayload(commitOid, ref, analysisKey, analysisName, zippedSarif, wo
   }
   return payloadObj;
 }
-async function postProcessSarifFiles(logger, features, checkoutPath, sarifPaths, category, analysis) {
-  logger.info(`Post-processing sarif files: ${JSON.stringify(sarifPaths)}`);
+async function postProcessSarifFiles(logger2, features, checkoutPath, sarifPaths, category, analysis) {
+  logger2.info(`Post-processing sarif files: ${JSON.stringify(sarifPaths)}`);
   const gitHubVersion = await getGitHubVersion();
   let sarifLog;
-  category = analysis.fixCategory(logger, category);
+  category = analysis.fixCategory(logger2, category);
   if (sarifPaths.length > 1) {
     for (const sarifPath of sarifPaths) {
       const parsedSarif = readSarifFileOrThrow(sarifPath);
-      validateSarifFileSchema(parsedSarif, sarifPath, logger);
+      validateSarifFileSchema(parsedSarif, sarifPath, logger2);
     }
     sarifLog = await combineSarifFilesUsingCLI(
       sarifPaths,
       gitHubVersion,
       features,
-      logger
+      logger2
     );
   } else {
     const sarifPath = sarifPaths[0];
     sarifLog = readSarifFileOrThrow(sarifPath);
-    validateSarifFileSchema(sarifLog, sarifPath, logger);
+    validateSarifFileSchema(sarifLog, sarifPath, logger2);
     await throwIfCombineSarifFilesDisabled([sarifLog], gitHubVersion);
   }
-  sarifLog = filterAlertsByDiffRange(logger, sarifLog);
-  sarifLog = await addFingerprints(sarifLog, checkoutPath, logger);
+  sarifLog = filterAlertsByDiffRange(logger2, sarifLog);
+  sarifLog = await addFingerprints(sarifLog, checkoutPath, logger2);
   const analysisKey = await getAnalysisKey();
   const environment = getRequiredInput("matrix");
   sarifLog = populateRunAutomationDetails(
@@ -157247,20 +157250,20 @@ async function postProcessSarifFiles(logger, features, checkoutPath, sarifPaths,
   );
   return { sarif: sarifLog, analysisKey, environment };
 }
-async function writePostProcessedFiles(logger, pathInput, uploadTarget, postProcessingResults) {
+async function writePostProcessedFiles(logger2, pathInput, uploadTarget, postProcessingResults) {
   const outputPath = pathInput || getOptionalEnvVar("CODEQL_ACTION_SARIF_DUMP_DIR" /* SARIF_DUMP_DIR */);
   if (outputPath !== void 0) {
     dumpSarifFile(
       JSON.stringify(postProcessingResults.sarif),
       outputPath,
-      logger,
+      logger2,
       uploadTarget
     );
   } else {
-    logger.debug(`Not writing post-processed SARIF files.`);
+    logger2.debug(`Not writing post-processed SARIF files.`);
   }
 }
-async function uploadFiles(inputSarifPath, checkoutPath, category, features, logger, uploadTarget) {
+async function uploadFiles(inputSarifPath, checkoutPath, category, features, logger2, uploadTarget) {
   const sarifPaths = getSarifFilePaths(
     inputSarifPath,
     uploadTarget.sarifPredicate
@@ -157270,13 +157273,13 @@ async function uploadFiles(inputSarifPath, checkoutPath, category, features, log
     checkoutPath,
     category,
     features,
-    logger,
+    logger2,
     uploadTarget
   );
 }
-async function uploadSpecifiedFiles(sarifPaths, checkoutPath, category, features, logger, uploadTarget) {
+async function uploadSpecifiedFiles(sarifPaths, checkoutPath, category, features, logger2, uploadTarget) {
   const processingResults = await postProcessSarifFiles(
-    logger,
+    logger2,
     features,
     checkoutPath,
     sarifPaths,
@@ -157284,21 +157287,21 @@ async function uploadSpecifiedFiles(sarifPaths, checkoutPath, category, features
     uploadTarget
   );
   return uploadPostProcessedFiles(
-    logger,
+    logger2,
     checkoutPath,
     uploadTarget,
     processingResults
   );
 }
-async function uploadPostProcessedFiles(logger, checkoutPath, uploadTarget, postProcessingResults) {
-  logger.startGroup(`Uploading ${uploadTarget.name} results`);
+async function uploadPostProcessedFiles(logger2, checkoutPath, uploadTarget, postProcessingResults) {
+  logger2.startGroup(`Uploading ${uploadTarget.name} results`);
   const sarifLog = postProcessingResults.sarif;
   const toolNames = getToolNames(sarifLog);
-  logger.debug(`Validating that each SARIF run has a unique category`);
+  logger2.debug(`Validating that each SARIF run has a unique category`);
   validateUniqueCategory(sarifLog, uploadTarget.sentinelPrefix);
-  logger.debug(`Serializing SARIF for upload`);
+  logger2.debug(`Serializing SARIF for upload`);
   const sarifPayload = JSON.stringify(sarifLog);
-  logger.debug(`Compressing serialized SARIF`);
+  logger2.debug(`Compressing serialized SARIF`);
   const zippedSarif = import_zlib.default.gzipSync(sarifPayload).toString("base64");
   const checkoutURI = url.pathToFileURL(checkoutPath).href;
   const payload = uploadTarget.transformPayload(
@@ -157317,18 +157320,18 @@ async function uploadPostProcessedFiles(logger, checkoutPath, uploadTarget, post
     )
   );
   const rawUploadSizeBytes = sarifPayload.length;
-  logger.debug(`Raw upload size: ${rawUploadSizeBytes} bytes`);
+  logger2.debug(`Raw upload size: ${rawUploadSizeBytes} bytes`);
   const zippedUploadSizeBytes = zippedSarif.length;
-  logger.debug(`Base64 zipped upload size: ${zippedUploadSizeBytes} bytes`);
+  logger2.debug(`Base64 zipped upload size: ${zippedUploadSizeBytes} bytes`);
   const numResultInSarif = countResultsInSarif(sarifPayload);
-  logger.debug(`Number of results in upload: ${numResultInSarif}`);
+  logger2.debug(`Number of results in upload: ${numResultInSarif}`);
   const sarifID = await uploadPayload(
     payload,
     getRepositoryNwo(),
-    logger,
+    logger2,
     uploadTarget
   );
-  logger.endGroup();
+  logger2.endGroup();
   return {
     statusReport: {
       raw_upload_size_bytes: rawUploadSizeBytes,
@@ -157338,7 +157341,7 @@ async function uploadPostProcessedFiles(logger, checkoutPath, uploadTarget, post
     sarifID
   };
 }
-function dumpSarifFile(sarifPayload, outputDir, logger, uploadTarget) {
+function dumpSarifFile(sarifPayload, outputDir, logger2, uploadTarget) {
   if (!fs22.existsSync(outputDir)) {
     fs22.mkdirSync(outputDir, { recursive: true });
   } else if (!fs22.lstatSync(outputDir).isDirectory()) {
@@ -157350,16 +157353,16 @@ function dumpSarifFile(sarifPayload, outputDir, logger, uploadTarget) {
     outputDir,
     `upload${uploadTarget.sarifExtension}`
   );
-  logger.info(`Writing processed SARIF file to ${outputFile}`);
+  logger2.info(`Writing processed SARIF file to ${outputFile}`);
   fs22.writeFileSync(outputFile, sarifPayload);
 }
 var STATUS_CHECK_INITIAL_BACKOFF_MILLISECONDS = 5 * 1e3;
 var STATUS_CHECK_BACKOFF_MULTIPLIER = 2;
 var STATUS_CHECK_MAX_TRIES = 5;
-async function waitForProcessing(repositoryNwo, sarifID, logger, options = {
+async function waitForProcessing(repositoryNwo, sarifID, logger2, options = {
   isUnsuccessfulExecution: false
 }) {
-  logger.startGroup("Waiting for processing to finish");
+  logger2.startGroup("Waiting for processing to finish");
   try {
     const client = getApiClient();
     let statusCheckBackoff = STATUS_CHECK_INITIAL_BACKOFF_MILLISECONDS;
@@ -157378,20 +157381,20 @@ async function waitForProcessing(repositoryNwo, sarifID, logger, options = {
           }
         );
       } catch (e) {
-        logger.warning(
+        logger2.warning(
           `An error occurred checking the status of the delivery. ${e} It should still be processed in the background, but errors that occur during processing may not be reported.`
         );
         break;
       }
       const status = response.data.processing_status;
-      logger.info(`Analysis upload status is ${status}.`);
+      logger2.info(`Analysis upload status is ${status}.`);
       if (status === "pending") {
-        logger.debug("Analysis processing is still pending...");
+        logger2.debug("Analysis processing is still pending...");
       } else if (options.isUnsuccessfulExecution) {
         handleProcessingResultForUnsuccessfulExecution(
           response,
           status,
-          logger
+          logger2
         );
         break;
       } else if (status === "complete") {
@@ -157405,7 +157408,7 @@ ${response.data.errors}`;
         assertNever(status);
       }
       if (statusCheckCount === STATUS_CHECK_MAX_TRIES) {
-        logger.warning(
+        logger2.warning(
           "Timed out waiting for analysis to finish processing. Continuing."
         );
         break;
@@ -157415,7 +157418,7 @@ ${response.data.errors}`;
       }
     }
   } finally {
-    logger.endGroup();
+    logger2.endGroup();
   }
 }
 function shouldConsiderConfigurationError(processingErrors) {
@@ -157435,18 +157438,18 @@ function shouldConsiderInvalidRequest(processingErrors) {
     )
   );
 }
-function handleProcessingResultForUnsuccessfulExecution(response, status, logger) {
+function handleProcessingResultForUnsuccessfulExecution(response, status, logger2) {
   if (status === "failed" && Array.isArray(response.data.errors) && response.data.errors.length === 1 && // eslint-disable-next-line @typescript-eslint/no-unsafe-call
   response.data.errors[0].toString().startsWith("unsuccessful execution")) {
-    logger.info(
+    logger2.info(
       'Successfully uploaded a SARIF file for the unsuccessful execution. Received expected "unsuccessful execution" processing error, and no other errors.'
     );
   } else if (status === "failed") {
-    logger.warning(
+    logger2.warning(
       `Failed to upload a SARIF file for the unsuccessful execution. Code scanning status information for the repository may be out of date as a result. Processing errors: ${response.data.errors}`
     );
   } else if (status === "complete") {
-    logger.debug(
+    logger2.debug(
       'Uploaded a SARIF file for the unsuccessful execution, but did not receive the expected "unsuccessful execution" processing error. This is a known transient issue with the code scanning API, and does not cause out of date code scanning status information.'
     );
   } else {
@@ -157474,8 +157477,8 @@ function validateUniqueCategory(sarifLog, sentinelPrefix) {
 function sanitize(str) {
   return (str ?? "_").replace(/[^a-zA-Z0-9_]/g, "_").toLocaleUpperCase();
 }
-function filterAlertsByDiffRange(logger, sarifLog) {
-  const diffRanges = readDiffRangesJsonFile(logger);
+function filterAlertsByDiffRange(logger2, sarifLog) {
+  const diffRanges = readDiffRangesJsonFile(logger2);
   if (!diffRanges?.length) {
     return sarifLog;
   }
@@ -157506,9 +157509,9 @@ function filterAlertsByDiffRange(logger, sarifLog) {
 }
 
 // src/upload-sarif.ts
-async function postProcessAndUploadSarif(logger, features, uploadKind, checkoutPath, sarifPath, category, postProcessedOutputPath) {
+async function postProcessAndUploadSarif(logger2, features, uploadKind, checkoutPath, sarifPath, category, postProcessedOutputPath) {
   const sarifGroups = await getGroupedSarifFilePaths(
-    logger,
+    logger2,
     sarifPath
   );
   const uploadResults = {};
@@ -157517,7 +157520,7 @@ async function postProcessAndUploadSarif(logger, features, uploadKind, checkoutP
   )) {
     const analysisConfig = getAnalysisConfig(analysisKind);
     const postProcessingResults = await postProcessSarifFiles(
-      logger,
+      logger2,
       features,
       checkoutPath,
       sarifFiles,
@@ -157525,14 +157528,14 @@ async function postProcessAndUploadSarif(logger, features, uploadKind, checkoutP
       analysisConfig
     );
     await writePostProcessedFiles(
-      logger,
+      logger2,
       postProcessedOutputPath,
       analysisConfig,
       postProcessingResults
     );
     if (uploadKind === "always") {
       uploadResults[analysisKind] = await uploadPostProcessedFiles(
-        logger,
+        logger2,
         checkoutPath,
         analysisConfig,
         postProcessingResults
@@ -157543,15 +157546,15 @@ async function postProcessAndUploadSarif(logger, features, uploadKind, checkoutP
 }
 
 // src/analyze-action.ts
-async function sendStatusReport2(startedAt, config, stats, error3, trapCacheUploadTime, dbCreationTimings, didUploadTrapCaches, trapCacheCleanup, dependencyCacheResults, databaseUploadResults, logger) {
+async function sendStatusReport2(startedAt, config, stats, error3, trapCacheUploadTime, dbCreationTimings, didUploadTrapCaches, trapCacheCleanup, dependencyCacheResults, databaseUploadResults, logger2) {
   const status = getActionsStatus(error3, stats?.analyze_failure_language);
   const statusReportBase = await createStatusReportBase(
     "finish" /* Analyze */,
     status,
     startedAt,
     config,
-    await checkDiskUsage(logger),
-    logger,
+    await checkDiskUsage(logger2),
+    logger2,
     error3?.message,
     error3?.stack
   );
@@ -157569,7 +157572,7 @@ async function sendStatusReport2(startedAt, config, stats, error3, trapCacheUplo
         ...report,
         trap_cache_upload_duration_ms: Math.round(trapCacheUploadTime || 0),
         trap_cache_upload_size_bytes: Math.round(
-          await getTotalCacheSize(Object.values(config.trapCaches), logger)
+          await getTotalCacheSize(Object.values(config.trapCaches), logger2)
         )
       };
       await sendStatusReport(trapCacheUploadStatusReport);
@@ -157602,41 +157605,41 @@ function doesGoExtractionOutputExist(config) {
     ].some((ext) => fileName.endsWith(ext))
   );
 }
-async function runAutobuildIfLegacyGoWorkflow(config, logger) {
+async function runAutobuildIfLegacyGoWorkflow(config, logger2) {
   if (!config.languages.includes("go" /* go */)) {
     return;
   }
   if (config.buildMode) {
-    logger.debug(
+    logger2.debug(
       "Skipping legacy Go autobuild since a build mode has been specified."
     );
     return;
   }
   if (process.env["CODEQL_ACTION_DID_AUTOBUILD_GOLANG" /* DID_AUTOBUILD_GOLANG */] === "true") {
-    logger.debug("Won't run Go autobuild since it has already been run.");
+    logger2.debug("Won't run Go autobuild since it has already been run.");
     return;
   }
-  if (dbIsFinalized(config, "go" /* go */, logger)) {
-    logger.debug(
+  if (dbIsFinalized(config, "go" /* go */, logger2)) {
+    logger2.debug(
       "Won't run Go autobuild since there is already a finalized database for Go."
     );
     return;
   }
   if (doesGoExtractionOutputExist(config)) {
-    logger.debug(
+    logger2.debug(
       "Won't run Go autobuild since at least one file of Go code has already been extracted."
     );
     if ("CODEQL_EXTRACTOR_GO_BUILD_TRACING" in process.env) {
-      logger.warning(
+      logger2.warning(
         `The CODEQL_EXTRACTOR_GO_BUILD_TRACING environment variable has no effect on workflows with manual build steps, so we recommend that you remove it from your workflow.`
       );
     }
     return;
   }
-  logger.debug(
+  logger2.debug(
     "Running Go autobuild because extraction output (TRAP files) for Go code has not been found."
   );
-  await runAutobuild(config, "go" /* go */, logger);
+  await runAutobuild(config, "go" /* go */, logger2);
 }
 async function run(startedAt) {
   let uploadResults = void 0;
@@ -157648,7 +157651,7 @@ async function run(startedAt) {
   let didUploadTrapCaches = false;
   let dependencyCacheResults;
   let databaseUploadResults = [];
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   try {
     initializeEnvironment(getActionVersion());
     persistInputs();
@@ -157657,13 +157660,13 @@ async function run(startedAt) {
       "starting",
       startedAt,
       config,
-      await checkDiskUsage(logger),
-      logger
+      await checkDiskUsage(logger2),
+      logger2
     );
     if (statusReportBase !== void 0) {
       await sendStatusReport(statusReportBase);
     }
-    config = await getConfig(getTemporaryDirectory(), logger);
+    config = await getConfig(getTemporaryDirectory(), logger2);
     if (config === void 0) {
       throw new ConfigurationError(
         "Config file could not be found at expected location. Has the 'init' action been called?"
@@ -157681,7 +157684,7 @@ async function run(startedAt) {
       delete process.env.CODEQL_PROXY_CA_CERTIFICATE;
     }
     if (getOptionalInput("cleanup-level")) {
-      logger.info(
+      logger2.info(
         "The 'cleanup-level' input is ignored since the CodeQL Action now automatically manages database cleanup. This input can safely be removed from your workflow."
       );
     }
@@ -157690,7 +157693,7 @@ async function run(startedAt) {
     core15.exportVariable("CODEQL_ACTION_SARIF_RESULTS_OUTPUT_DIR" /* SARIF_RESULTS_OUTPUT_DIR */, outputDir);
     const threads = getThreadsFlag(
       getOptionalInput("threads") || process.env["CODEQL_THREADS"],
-      logger
+      logger2
     );
     const repositoryNwo = getRepositoryNwo();
     const gitHubVersion = await getGitHubVersion();
@@ -157699,15 +157702,15 @@ async function run(startedAt) {
       gitHubVersion,
       repositoryNwo,
       getTemporaryDirectory(),
-      logger
+      logger2
     );
     const memory = getMemoryFlag(
       getOptionalInput("ram") || process.env["CODEQL_RAM"],
-      logger
+      logger2
     );
-    const diffRangePackDir = await setupDiffInformedQueryRun(logger);
-    await warnIfGoInstalledAfterInit(config, logger);
-    await runAutobuildIfLegacyGoWorkflow(config, logger);
+    const diffRangePackDir = await setupDiffInformedQueryRun(logger2);
+    await warnIfGoInstalledAfterInit(config, logger2);
+    await runAutobuildIfLegacyGoWorkflow(config, logger2);
     dbCreationTimings = await runFinalize(
       features,
       outputDir,
@@ -157715,11 +157718,11 @@ async function run(startedAt) {
       memory,
       codeql,
       config,
-      logger
+      logger2
     );
     if (getRequiredInput("skip-queries") !== "true") {
       if (getOptionalInput("add-snippets") !== void 0) {
-        logger.warning(
+        logger2.warning(
           "The `add-snippets` input has been removed and no longer has any effect."
         );
       }
@@ -157731,7 +157734,7 @@ async function run(startedAt) {
         getOptionalInput("category"),
         codeql,
         config,
-        logger,
+        logger2,
         features
       );
     }
@@ -157748,7 +157751,7 @@ async function run(startedAt) {
       const checkoutPath = getRequiredInput("checkout_path");
       const category = getOptionalInput("category");
       uploadResults = await postProcessAndUploadSarif(
-        logger,
+        logger2,
         features,
         uploadKind,
         checkoutPath,
@@ -157769,35 +157772,35 @@ async function run(startedAt) {
         );
       }
     } else {
-      logger.info("Not uploading results");
+      logger2.info("Not uploading results");
     }
-    await cleanupAndUploadOverlayBaseDatabaseToCache(codeql, config, logger);
+    await cleanupAndUploadOverlayBaseDatabaseToCache(codeql, config, logger2);
     databaseUploadResults = await cleanupAndUploadDatabases(
       repositoryNwo,
       codeql,
       config,
       apiDetails,
       features,
-      logger
+      logger2
     );
     const trapCacheUploadStartTime = import_perf_hooks4.performance.now();
-    didUploadTrapCaches = await uploadTrapCaches(codeql, config, logger);
+    didUploadTrapCaches = await uploadTrapCaches(codeql, config, logger2);
     trapCacheUploadTime = import_perf_hooks4.performance.now() - trapCacheUploadStartTime;
     trapCacheCleanupTelemetry = await cleanupTrapCaches(
       config,
       features,
-      logger
+      logger2
     );
     if (shouldStoreCache(config.dependencyCachingEnabled)) {
       dependencyCacheResults = await uploadDependencyCaches(
         codeql,
         features,
         config,
-        logger
+        logger2
       );
     }
     if (isInTestMode()) {
-      logger.debug("In test mode. Waiting for processing is disabled.");
+      logger2.debug("In test mode. Waiting for processing is disabled.");
     } else if (uploadResults?.["code-scanning" /* CodeScanning */] !== void 0 && getRequiredInput("wait-for-processing") === "true") {
       await waitForProcessing(
         getRepositoryNwo(),
@@ -157827,7 +157830,7 @@ async function run(startedAt) {
       trapCacheCleanupTelemetry,
       dependencyCacheResults,
       databaseUploadResults,
-      logger
+      logger2
     );
     return;
   }
@@ -157846,7 +157849,7 @@ async function run(startedAt) {
       trapCacheCleanupTelemetry,
       dependencyCacheResults,
       databaseUploadResults,
-      logger
+      logger2
     );
   } else if (runStats !== void 0) {
     await sendStatusReport2(
@@ -157860,7 +157863,7 @@ async function run(startedAt) {
       trapCacheCleanupTelemetry,
       dependencyCacheResults,
       databaseUploadResults,
-      logger
+      logger2
     );
   } else {
     await sendStatusReport2(
@@ -157874,13 +157877,13 @@ async function run(startedAt) {
       trapCacheCleanupTelemetry,
       dependencyCacheResults,
       databaseUploadResults,
-      logger
+      logger2
     );
   }
 }
 async function runWrapper() {
   const startedAt = /* @__PURE__ */ new Date();
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   try {
     await run(startedAt);
   } catch (error3) {
@@ -157889,7 +157892,7 @@ async function runWrapper() {
       "finish" /* Analyze */,
       startedAt,
       error3,
-      logger
+      logger2
     );
   }
   await checkForTimeout();
@@ -157952,7 +157955,7 @@ function isAuthToken(value, patterns = GITHUB_TOKEN_PATTERNS) {
   }
   return void 0;
 }
-function scanFileForTokens(filePath, relativePath, logger) {
+function scanFileForTokens(filePath, relativePath, logger2) {
   const findings = [];
   try {
     const content = fs24.readFileSync(filePath, "utf8");
@@ -157962,18 +157965,18 @@ function scanFileForTokens(filePath, relativePath, logger) {
         for (let i = 0; i < matches.length; i++) {
           findings.push({ tokenType: type, filePath: relativePath });
         }
-        logger.debug(`Found ${matches.length} ${type}(s) in ${relativePath}`);
+        logger2.debug(`Found ${matches.length} ${type}(s) in ${relativePath}`);
       }
     }
     return findings;
   } catch (e) {
-    logger.debug(
+    logger2.debug(
       `Could not scan file ${filePath} for tokens: ${getErrorMessage(e)}`
     );
     return [];
   }
 }
-async function scanArchiveFile(archivePath, relativeArchivePath, extractDir, logger, depth = 0) {
+async function scanArchiveFile(archivePath, relativeArchivePath, extractDir, logger2, depth = 0) {
   const MAX_DEPTH = 10;
   if (depth > MAX_DEPTH) {
     throw new Error(
@@ -157993,12 +157996,12 @@ async function scanArchiveFile(archivePath, relativeArchivePath, extractDir, log
     );
     const fileName = path21.basename(archivePath).toLowerCase();
     if (fileName.endsWith(".tar.gz") || fileName.endsWith(".tgz")) {
-      logger.debug(`Extracting tar.gz file: ${archivePath}`);
+      logger2.debug(`Extracting tar.gz file: ${archivePath}`);
       await exec.exec("tar", ["-xzf", archivePath, "-C", tempExtractDir], {
         silent: true
       });
     } else if (fileName.endsWith(".tar.zst")) {
-      logger.debug(`Extracting tar.zst file: ${archivePath}`);
+      logger2.debug(`Extracting tar.zst file: ${archivePath}`);
       await exec.exec(
         "tar",
         ["--zstd", "-xf", archivePath, "-C", tempExtractDir],
@@ -158007,7 +158010,7 @@ async function scanArchiveFile(archivePath, relativeArchivePath, extractDir, log
         }
       );
     } else if (fileName.endsWith(".zst")) {
-      logger.debug(`Extracting zst file: ${archivePath}`);
+      logger2.debug(`Extracting zst file: ${archivePath}`);
       const outputFile = path21.join(
         tempExtractDir,
         path21.basename(archivePath, ".zst")
@@ -158016,7 +158019,7 @@ async function scanArchiveFile(archivePath, relativeArchivePath, extractDir, log
         silent: true
       });
     } else if (fileName.endsWith(".gz")) {
-      logger.debug(`Extracting gz file: ${archivePath}`);
+      logger2.debug(`Extracting gz file: ${archivePath}`);
       const outputFile = path21.join(
         tempExtractDir,
         path21.basename(archivePath, ".gz")
@@ -158026,7 +158029,7 @@ async function scanArchiveFile(archivePath, relativeArchivePath, extractDir, log
         silent: true
       });
     } else if (fileName.endsWith(".zip")) {
-      logger.debug(`Extracting zip file: ${archivePath}`);
+      logger2.debug(`Extracting zip file: ${archivePath}`);
       await exec.exec(
         "unzip",
         ["-q", "-o", archivePath, "-d", tempExtractDir],
@@ -158038,20 +158041,20 @@ async function scanArchiveFile(archivePath, relativeArchivePath, extractDir, log
     const scanResult = await scanDirectory(
       tempExtractDir,
       relativeArchivePath,
-      logger,
+      logger2,
       depth + 1
     );
     result.scannedFiles += scanResult.scannedFiles;
     result.findings.push(...scanResult.findings);
     fs24.rmSync(tempExtractDir, { recursive: true, force: true });
   } catch (e) {
-    logger.debug(
+    logger2.debug(
       `Could not extract or scan archive file ${archivePath}: ${getErrorMessage(e)}`
     );
   }
   return result;
 }
-async function scanFile(fullPath, relativePath, extractDir, logger, depth = 0) {
+async function scanFile(fullPath, relativePath, extractDir, logger2, depth = 0) {
   const result = {
     scannedFiles: 1,
     findings: []
@@ -158063,17 +158066,17 @@ async function scanFile(fullPath, relativePath, extractDir, logger, depth = 0) {
       fullPath,
       relativePath,
       extractDir,
-      logger,
+      logger2,
       depth
     );
     result.scannedFiles += archiveResult.scannedFiles;
     result.findings.push(...archiveResult.findings);
   }
-  const fileFindings = scanFileForTokens(fullPath, relativePath, logger);
+  const fileFindings = scanFileForTokens(fullPath, relativePath, logger2);
   result.findings.push(...fileFindings);
   return result;
 }
-async function scanDirectory(dirPath, baseRelativePath, logger, depth = 0) {
+async function scanDirectory(dirPath, baseRelativePath, logger2, depth = 0) {
   const result = {
     scannedFiles: 0,
     findings: []
@@ -158086,7 +158089,7 @@ async function scanDirectory(dirPath, baseRelativePath, logger, depth = 0) {
       const subResult = await scanDirectory(
         fullPath,
         relativePath,
-        logger,
+        logger2,
         depth
       );
       result.scannedFiles += subResult.scannedFiles;
@@ -158096,7 +158099,7 @@ async function scanDirectory(dirPath, baseRelativePath, logger, depth = 0) {
         fullPath,
         relativePath,
         path21.dirname(fullPath),
-        logger,
+        logger2,
         depth
       );
       result.scannedFiles += fileResult.scannedFiles;
@@ -158105,8 +158108,8 @@ async function scanDirectory(dirPath, baseRelativePath, logger, depth = 0) {
   }
   return result;
 }
-async function scanArtifactsForTokens(filesToScan, logger) {
-  logger.info(
+async function scanArtifactsForTokens(filesToScan, logger2) {
+  logger2.info(
     "Starting best-effort check for potential GitHub tokens in debug artifacts (for testing purposes only)..."
   );
   const result = {
@@ -158119,7 +158122,7 @@ async function scanArtifactsForTokens(filesToScan, logger) {
       const stats = fs24.statSync(filePath);
       const fileName = path21.basename(filePath);
       if (stats.isDirectory()) {
-        const dirResult = await scanDirectory(filePath, fileName, logger);
+        const dirResult = await scanDirectory(filePath, fileName, logger2);
         result.scannedFiles += dirResult.scannedFiles;
         result.findings.push(...dirResult.findings);
       } else if (stats.isFile()) {
@@ -158127,7 +158130,7 @@ async function scanArtifactsForTokens(filesToScan, logger) {
           filePath,
           fileName,
           tempScanDir,
-          logger
+          logger2
         );
         result.scannedFiles += fileResult.scannedFiles;
         result.findings.push(...fileResult.findings);
@@ -158145,7 +158148,7 @@ async function scanArtifactsForTokens(filesToScan, logger) {
     const tokenTypesSummary = Array.from(tokenTypesCounts.entries()).map(([type, count]) => `${count} ${type}${count > 1 ? "s" : ""}`).join(", ");
     const baseSummary = `scanned ${result.scannedFiles} files, found ${result.findings.length} potential token(s) in ${filesWithTokens.size} file(s)`;
     const summaryWithTypes = tokenTypesSummary ? `${baseSummary} (${tokenTypesSummary})` : baseSummary;
-    logger.info(`Artifact check complete: ${summaryWithTypes}`);
+    logger2.info(`Artifact check complete: ${summaryWithTypes}`);
     if (result.findings.length > 0) {
       const fileList = Array.from(filesWithTokens).join(", ");
       throw new Error(
@@ -158156,7 +158159,7 @@ async function scanArtifactsForTokens(filesToScan, logger) {
     try {
       fs24.rmSync(tempScanDir, { recursive: true, force: true });
     } catch (e) {
-      logger.debug(
+      logger2.debug(
         `Could not clean up temporary scan directory: ${getErrorMessage(e)}`
       );
     }
@@ -158167,11 +158170,11 @@ async function scanArtifactsForTokens(filesToScan, logger) {
 function sanitizeArtifactName(name) {
   return name.replace(/[^a-zA-Z0-9_-]+/g, "");
 }
-async function uploadCombinedSarifArtifacts(logger, gitHubVariant, codeQlVersion) {
+async function uploadCombinedSarifArtifacts(logger2, gitHubVariant, codeQlVersion) {
   const tempDir = getTemporaryDirectory();
   if (process.env["CODEQL_ACTION_DEBUG_COMBINED_SARIF"] === "true") {
     await withGroup("Uploading combined SARIF debug artifact", async () => {
-      logger.info(
+      logger2.info(
         "Uploading available combined SARIF files as Actions debugging artifact..."
       );
       const baseTempDir = path22.resolve(tempDir, "combined-sarif");
@@ -158187,7 +158190,7 @@ async function uploadCombinedSarifArtifacts(logger, gitHubVariant, codeQlVersion
       }
       try {
         await uploadDebugArtifacts(
-          logger,
+          logger2,
           toUpload,
           baseTempDir,
           "combined-sarif-artifacts",
@@ -158195,7 +158198,7 @@ async function uploadCombinedSarifArtifacts(logger, gitHubVariant, codeQlVersion
           codeQlVersion
         );
       } catch (e) {
-        logger.warning(
+        logger2.warning(
           `Failed to upload combined SARIF files as Actions debugging artifact. Reason: ${getErrorMessage(
             e
           )}`
@@ -158204,7 +158207,7 @@ async function uploadCombinedSarifArtifacts(logger, gitHubVariant, codeQlVersion
     });
   }
 }
-function tryPrepareSarifDebugArtifact(config, language, logger) {
+function tryPrepareSarifDebugArtifact(config, language, logger2) {
   try {
     const analyzeActionOutputDir = process.env["CODEQL_ACTION_SARIF_RESULTS_OUTPUT_DIR" /* SARIF_RESULTS_OUTPUT_DIR */];
     if (analyzeActionOutputDir !== void 0 && fs25.existsSync(analyzeActionOutputDir) && fs25.lstatSync(analyzeActionOutputDir).isDirectory()) {
@@ -158222,7 +158225,7 @@ function tryPrepareSarifDebugArtifact(config, language, logger) {
       }
     }
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to find SARIF results path for ${language}. Reason: ${getErrorMessage(
         e
       )}`
@@ -158230,20 +158233,20 @@ function tryPrepareSarifDebugArtifact(config, language, logger) {
   }
   return void 0;
 }
-async function tryBundleDatabase(codeql, config, language, logger) {
+async function tryBundleDatabase(codeql, config, language, logger2) {
   try {
-    if (dbIsFinalized(config, language, logger)) {
+    if (dbIsFinalized(config, language, logger2)) {
       try {
         return await createDatabaseBundleCli(codeql, config, language);
       } catch (e) {
-        logger.warning(
+        logger2.warning(
           `Failed to bundle database for ${language} using the CLI. Falling back to a partial bundle. Reason: ${getErrorMessage(e)}`
         );
       }
     }
     return await createPartialDatabaseBundle(config, language);
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to bundle database for ${language}. Reason: ${getErrorMessage(
         e
       )}`
@@ -158251,52 +158254,52 @@ async function tryBundleDatabase(codeql, config, language, logger) {
     return void 0;
   }
 }
-async function tryUploadAllAvailableDebugArtifacts(codeql, config, logger, codeQlVersion) {
+async function tryUploadAllAvailableDebugArtifacts(codeql, config, logger2, codeQlVersion) {
   const filesToUpload = [];
   try {
     for (const language of config.languages) {
       await withGroup(`Uploading debug artifacts for ${language}`, async () => {
-        logger.info("Preparing SARIF result debug artifact...");
+        logger2.info("Preparing SARIF result debug artifact...");
         const sarifResultDebugArtifact = tryPrepareSarifDebugArtifact(
           config,
           language,
-          logger
+          logger2
         );
         if (sarifResultDebugArtifact) {
           filesToUpload.push(sarifResultDebugArtifact);
-          logger.info("SARIF result debug artifact ready for upload.");
+          logger2.info("SARIF result debug artifact ready for upload.");
         }
-        logger.info("Preparing database logs debug artifact...");
+        logger2.info("Preparing database logs debug artifact...");
         const databaseDirectory = getCodeQLDatabasePath(config, language);
         const logsDirectory = path22.resolve(databaseDirectory, "log");
         if (doesDirectoryExist(logsDirectory)) {
           filesToUpload.push(...listFolder(logsDirectory));
-          logger.info("Database logs debug artifact ready for upload.");
+          logger2.info("Database logs debug artifact ready for upload.");
         }
-        logger.info("Preparing database cluster logs debug artifact...");
+        logger2.info("Preparing database cluster logs debug artifact...");
         const multiLanguageTracingLogsDirectory = path22.resolve(
           config.dbLocation,
           "log"
         );
         if (doesDirectoryExist(multiLanguageTracingLogsDirectory)) {
           filesToUpload.push(...listFolder(multiLanguageTracingLogsDirectory));
-          logger.info("Database cluster logs debug artifact ready for upload.");
+          logger2.info("Database cluster logs debug artifact ready for upload.");
         }
-        logger.info("Preparing database bundle debug artifact...");
+        logger2.info("Preparing database bundle debug artifact...");
         const databaseBundle = await tryBundleDatabase(
           codeql,
           config,
           language,
-          logger
+          logger2
         );
         if (databaseBundle) {
           filesToUpload.push(databaseBundle);
-          logger.info("Database bundle debug artifact ready for upload.");
+          logger2.info("Database bundle debug artifact ready for upload.");
         }
       });
     }
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to prepare debug artifacts. Reason: ${getErrorMessage(e)}`
     );
     return;
@@ -158305,7 +158308,7 @@ async function tryUploadAllAvailableDebugArtifacts(codeql, config, logger, codeQ
     await withGroup(
       "Uploading debug artifacts",
       async () => uploadDebugArtifacts(
-        logger,
+        logger2,
         filesToUpload,
         config.dbLocation,
         config.debugArtifactName,
@@ -158314,7 +158317,7 @@ async function tryUploadAllAvailableDebugArtifacts(codeql, config, logger, codeQ
       )
     );
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to upload debug artifacts. Reason: ${getErrorMessage(e)}`
     );
   }
@@ -158338,7 +158341,7 @@ function getArtifactSuffix(matrix) {
   }
   return suffix;
 }
-async function uploadDebugArtifacts(logger, toUpload, rootDir, artifactName, ghVariant, codeQlVersion) {
+async function uploadDebugArtifacts(logger2, toUpload, rootDir, artifactName, ghVariant, codeQlVersion) {
   const uploadSupported = isSafeArtifactUpload(codeQlVersion);
   if (!uploadSupported) {
     core16.info(
@@ -158346,18 +158349,18 @@ async function uploadDebugArtifacts(logger, toUpload, rootDir, artifactName, ghV
     );
     return "upload-not-supported";
   }
-  return uploadArtifacts(logger, toUpload, rootDir, artifactName, ghVariant);
+  return uploadArtifacts(logger2, toUpload, rootDir, artifactName, ghVariant);
 }
-async function uploadArtifacts(logger, toUpload, rootDir, artifactName, ghVariant) {
+async function uploadArtifacts(logger2, toUpload, rootDir, artifactName, ghVariant) {
   if (toUpload.length === 0) {
     return "no-artifacts-to-upload";
   }
   if (isInTestMode()) {
-    await scanArtifactsForTokens(toUpload, logger);
+    await scanArtifactsForTokens(toUpload, logger2);
     core16.exportVariable("CODEQL_ACTION_ARTIFACT_SCAN_FINISHED", "true");
   }
   const suffix = getArtifactSuffix(getOptionalInput("matrix"));
-  const artifactUploader = await getArtifactUploaderClient(logger, ghVariant);
+  const artifactUploader = await getArtifactUploaderClient(logger2, ghVariant);
   try {
     await artifactUploader.uploadArtifact(
       sanitizeArtifactName(`${artifactName}${suffix}`),
@@ -158374,14 +158377,14 @@ async function uploadArtifacts(logger, toUpload, rootDir, artifactName, ghVarian
     return "upload-failed";
   }
 }
-async function getArtifactUploaderClient(logger, ghVariant) {
+async function getArtifactUploaderClient(logger2, ghVariant) {
   if (ghVariant === "GitHub Enterprise Server" /* GHES */) {
-    logger.info(
+    logger2.info(
       "Debug artifacts can be consumed with `actions/download-artifact@v3` because the `v4` version is not yet compatible on GHES."
     );
     return artifactLegacy.create();
   } else {
-    logger.info(
+    logger2.info(
       "Debug artifacts can be consumed with `actions/download-artifact@v4`."
     );
     return new artifact.DefaultArtifactClient();
@@ -158429,19 +158432,19 @@ async function createDatabaseBundleCli(codeql, config, language) {
 async function runWrapper2() {
   try {
     restoreInputs();
-    const logger = getActionsLogger();
+    const logger2 = getActionsLogger();
     const gitHubVersion = await getGitHubVersion();
-    checkGitHubVersionInRange(gitHubVersion, logger);
+    checkGitHubVersionInRange(gitHubVersion, logger2);
     if (process.env["CODEQL_ACTION_INIT_HAS_RUN" /* INIT_ACTION_HAS_RUN */] === "true") {
       const config = await getConfig(
         getTemporaryDirectory(),
-        logger
+        logger2
       );
       if (config !== void 0) {
         const codeql = await getCodeQL(config.codeQLCmd);
         const version = await codeql.getVersion();
         await uploadCombinedSarifArtifacts(
-          logger,
+          logger2,
           config.gitHubVersion.type,
           version.version
         );
@@ -158456,7 +158459,7 @@ async function runWrapper2() {
         try {
           fs26.rmSync(tempDependencyDir, { recursive: true });
         } catch (error3) {
-          logger.info(
+          logger2.info(
             `Failed to remove temporary dependencies directory: ${getErrorMessage(error3)}`
           );
         }
@@ -158471,7 +158474,7 @@ async function runWrapper2() {
 
 // src/autobuild-action.ts
 var core18 = __toESM(require_core());
-async function sendCompletedStatusReport(config, logger, startedAt, allLanguages, failingLanguage, cause) {
+async function sendCompletedStatusReport(config, logger2, startedAt, allLanguages, failingLanguage, cause) {
   initializeEnvironment(getActionVersion());
   const status = getActionsStatus(cause, failingLanguage);
   const statusReportBase = await createStatusReportBase(
@@ -158479,8 +158482,8 @@ async function sendCompletedStatusReport(config, logger, startedAt, allLanguages
     status,
     startedAt,
     config,
-    await checkDiskUsage(logger),
-    logger,
+    await checkDiskUsage(logger2),
+    logger2,
     cause?.message,
     cause?.stack
   );
@@ -158494,7 +158497,7 @@ async function sendCompletedStatusReport(config, logger, startedAt, allLanguages
   }
 }
 async function run2(startedAt) {
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   let config;
   let currentLanguage;
   let languages;
@@ -158504,37 +158507,37 @@ async function run2(startedAt) {
       "starting",
       startedAt,
       config,
-      await checkDiskUsage(logger),
-      logger
+      await checkDiskUsage(logger2),
+      logger2
     );
     if (statusReportBase !== void 0) {
       await sendStatusReport(statusReportBase);
     }
     const gitHubVersion = await getGitHubVersion();
-    checkGitHubVersionInRange(gitHubVersion, logger);
+    checkGitHubVersionInRange(gitHubVersion, logger2);
     checkActionVersion(getActionVersion(), gitHubVersion);
-    config = await getConfig(getTemporaryDirectory(), logger);
+    config = await getConfig(getTemporaryDirectory(), logger2);
     if (config === void 0) {
       throw new ConfigurationError(
         "Config file could not be found at expected location. Has the 'init' action been called?"
       );
     }
     const codeql = await getCodeQL(config.codeQLCmd);
-    languages = await determineAutobuildLanguages(codeql, config, logger);
+    languages = await determineAutobuildLanguages(codeql, config, logger2);
     if (languages !== void 0) {
       const workingDirectory = getOptionalInput("working-directory");
       if (workingDirectory) {
-        logger.info(
+        logger2.info(
           `Changing autobuilder working directory to ${workingDirectory}`
         );
         process.chdir(workingDirectory);
       }
       for (const language of languages) {
         currentLanguage = language;
-        await runAutobuild(config, language, logger);
+        await runAutobuild(config, language, logger2);
       }
     }
-    await endTracingForCluster(codeql, config, logger);
+    await endTracingForCluster(codeql, config, logger2);
   } catch (unwrappedError) {
     const error3 = wrapError(unwrappedError);
     core18.setFailed(
@@ -158542,7 +158545,7 @@ async function run2(startedAt) {
     );
     await sendCompletedStatusReport(
       config,
-      logger,
+      logger2,
       startedAt,
       languages ?? [],
       currentLanguage,
@@ -158551,11 +158554,11 @@ async function run2(startedAt) {
     return;
   }
   core18.exportVariable("CODEQL_ACTION_AUTOBUILD_DID_COMPLETE_SUCCESSFULLY" /* AUTOBUILD_DID_COMPLETE_SUCCESSFULLY */, "true");
-  await sendCompletedStatusReport(config, logger, startedAt, languages ?? []);
+  await sendCompletedStatusReport(config, logger2, startedAt, languages ?? []);
 }
 async function runWrapper3() {
   const startedAt = /* @__PURE__ */ new Date();
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   try {
     await run2(startedAt);
   } catch (error3) {
@@ -158564,7 +158567,7 @@ async function runWrapper3() {
       "autobuild" /* Autobuild */,
       startedAt,
       error3,
-      logger
+      logger2
     );
   }
 }
@@ -158578,15 +158581,15 @@ var io7 = __toESM(require_io());
 var semver10 = __toESM(require_semver2());
 
 // src/config/file.ts
-function getConfigFileInput(logger, actions, repositoryProperties) {
+function getConfigFileInput(logger2, actions, repositoryProperties) {
   const input = actions.getOptionalInput("config-file");
   if (input !== void 0) {
-    logger.info(`Using configuration file input from workflow: ${input}`);
+    logger2.info(`Using configuration file input from workflow: ${input}`);
     return input;
   }
   const propertyValue = repositoryProperties["github-codeql-config-file" /* CONFIG_FILE */];
   if (propertyValue !== void 0 && propertyValue.trim().length > 0) {
-    logger.info(
+    logger2.info(
       `Using configuration file input from repository property: ${propertyValue}`
     );
     return propertyValue;
@@ -158701,10 +158704,10 @@ function hasWorkflowTrigger(triggerName, doc) {
   }
   return Object.prototype.hasOwnProperty.call(doc.on, triggerName);
 }
-async function validateWorkflow(codeql, logger) {
+async function validateWorkflow(codeql, logger2) {
   let workflow;
   try {
-    workflow = await getWorkflow(logger);
+    workflow = await getWorkflow(logger2);
   } catch (e) {
     return `error: getWorkflow() failed: ${String(e)}`;
   }
@@ -158736,27 +158739,27 @@ function formatWorkflowCause(errors) {
   }
   return errors.map((e) => e.code).join(",");
 }
-async function getWorkflow(logger) {
+async function getWorkflow(logger2) {
   const maybeWorkflow = process.env["CODE_SCANNING_WORKFLOW_FILE"];
   if (maybeWorkflow) {
-    logger.debug(
+    logger2.debug(
       "Using the workflow specified by the CODE_SCANNING_WORKFLOW_FILE environment variable."
     );
     return load(
       import_zlib2.default.gunzipSync(Buffer.from(maybeWorkflow, "base64")).toString()
     );
   }
-  const workflowPath = await getWorkflowAbsolutePath(logger);
+  const workflowPath = await getWorkflowAbsolutePath(logger2);
   return load(fs27.readFileSync(workflowPath, "utf-8"));
 }
-async function getWorkflowAbsolutePath(logger) {
+async function getWorkflowAbsolutePath(logger2) {
   const relativePath = await getWorkflowRelativePath();
   const absolutePath = path23.join(
     getRequiredEnvParam("GITHUB_WORKSPACE"),
     relativePath
   );
   if (fs27.existsSync(absolutePath)) {
-    logger.debug(
+    logger2.debug(
       `Derived the following absolute path for the currently executing workflow: ${absolutePath}.`
     );
     return absolutePath;
@@ -158848,17 +158851,17 @@ function getCheckoutPathInputOrThrow(workflow, jobName, matrixVars) {
     matrixVars
   ) || getRequiredEnvParam("GITHUB_WORKSPACE");
 }
-async function checkWorkflow(logger, codeql) {
+async function checkWorkflow(logger2, codeql) {
   if (!isDynamicWorkflow() && process.env["CODEQL_ACTION_SKIP_WORKFLOW_VALIDATION" /* SKIP_WORKFLOW_VALIDATION */] !== "true") {
     core19.startGroup("Validating workflow");
     const validateWorkflowResult = await internal2.validateWorkflow(
       codeql,
-      logger
+      logger2
     );
     if (validateWorkflowResult === void 0) {
-      logger.info("Detected no issues with the code scanning workflow.");
+      logger2.info("Detected no issues with the code scanning workflow.");
     } else {
-      logger.debug(
+      logger2.debug(
         `Unable to validate code scanning workflow: ${validateWorkflowResult}`
       );
     }
@@ -158871,27 +158874,27 @@ var internal2 = {
 
 // src/init-action.ts
 var CODEQL_VERSION_JAR_MINIMIZATION = "2.23.0";
-async function sendStartingStatusReport(startedAt, config, logger) {
+async function sendStartingStatusReport(startedAt, config, logger2) {
   const statusReportBase = await createStatusReportBase(
     "init" /* Init */,
     "starting",
     startedAt,
     config,
-    await checkDiskUsage(logger),
-    logger
+    await checkDiskUsage(logger2),
+    logger2
   );
   if (statusReportBase !== void 0) {
     await sendStatusReport(statusReportBase);
   }
 }
-async function sendCompletedStatusReport2(startedAt, config, configFile, toolsDownloadStatusReport, toolsFeatureFlagsValid, toolsSource, toolsVersion, overlayBaseDatabaseStats, dependencyCachingResults, logger, error3) {
+async function sendCompletedStatusReport2(startedAt, config, configFile, toolsDownloadStatusReport, toolsFeatureFlagsValid, toolsSource, toolsVersion, overlayBaseDatabaseStats, dependencyCachingResults, logger2, error3) {
   const statusReportBase = await createStatusReportBase(
     "init" /* Init */,
     getActionsStatus(error3),
     startedAt,
     config,
-    await checkDiskUsage(logger),
-    logger,
+    await checkDiskUsage(logger2),
+    logger2,
     error3?.message,
     error3?.stack
   );
@@ -158919,7 +158922,7 @@ async function sendCompletedStatusReport2(startedAt, config, configFile, toolsDo
       initStatusReport,
       configFile,
       Math.round(
-        await getTotalCacheSize(Object.values(config.trapCaches), logger)
+        await getTotalCacheSize(Object.values(config.trapCaches), logger2)
       ),
       overlayBaseDatabaseStats,
       dependencyCachingResults
@@ -158933,7 +158936,7 @@ async function sendCompletedStatusReport2(startedAt, config, configFile, toolsDo
   }
 }
 async function run3(startedAt) {
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   const actionsEnv = getActionsEnv();
   let apiDetails;
   let config;
@@ -158956,38 +158959,38 @@ async function run3(startedAt) {
       apiURL: getRequiredEnvParam("GITHUB_API_URL")
     };
     const gitHubVersion = await getGitHubVersion();
-    checkGitHubVersionInRange(gitHubVersion, logger);
+    checkGitHubVersionInRange(gitHubVersion, logger2);
     checkActionVersion(getActionVersion(), gitHubVersion);
     const repositoryNwo = getRepositoryNwo();
     features = initFeatures(
       gitHubVersion,
       repositoryNwo,
       getTemporaryDirectory(),
-      logger
+      logger2
     );
     const repositoryPropertiesResult = await loadRepositoryProperties(
       repositoryNwo,
-      logger
+      logger2
     );
     const repositoryProperties = repositoryPropertiesResult.orElse({});
     const jobRunUuid = v4_default();
-    logger.info(`Job run UUID is ${jobRunUuid}.`);
+    logger2.info(`Job run UUID is ${jobRunUuid}.`);
     core20.exportVariable("JOB_RUN_UUID" /* JOB_RUN_UUID */, jobRunUuid);
     core20.exportVariable("CODEQL_ACTION_INIT_HAS_RUN" /* INIT_ACTION_HAS_RUN */, "true");
-    configFile = getConfigFileInput(logger, actionsEnv, repositoryProperties);
+    configFile = getConfigFileInput(logger2, actionsEnv, repositoryProperties);
     sourceRoot = path24.resolve(
       getRequiredEnvParam("GITHUB_WORKSPACE"),
       getOptionalInput("source-root") || ""
     );
     let analysisKinds;
     try {
-      analysisKinds = await getAnalysisKinds(logger, features);
+      analysisKinds = await getAnalysisKinds(logger2, features);
     } catch (err) {
-      logger.debug(
+      logger2.debug(
         `Failed to parse analysis kinds for 'starting' status report: ${getErrorMessage(err)}`
       );
     }
-    await sendStartingStatusReport(startedAt, { analysisKinds }, logger);
+    await sendStartingStatusReport(startedAt, { analysisKinds }, logger2);
     if (process.env["CODEQL_ACTION_SETUP_CODEQL_HAS_RUN" /* SETUP_CODEQL_ACTION_HAS_RUN */] === "true") {
       throw new ConfigurationError(
         `The 'init' action should not be run in the same workflow as 'setup-codeql'.`
@@ -159008,14 +159011,14 @@ async function run3(startedAt) {
       rawLanguages,
       useOverlayAwareDefaultCliVersion,
       features,
-      logger
+      logger2
     );
     codeql = initCodeQLResult.codeql;
     toolsDownloadStatusReport = initCodeQLResult.toolsDownloadStatusReport;
     toolsVersion = initCodeQLResult.toolsVersion;
     toolsSource = initCodeQLResult.toolsSource;
     zstdAvailability = initCodeQLResult.zstdAvailability;
-    await checkWorkflow(logger, codeql);
+    await checkWorkflow(logger2, codeql);
     if (
       // Only enable the experimental features env variable for Rust analysis if the user has explicitly
       // requested rust - don't enable it via language autodetection.
@@ -159031,10 +159034,10 @@ async function run3(startedAt) {
       }
       if (semver10.lt(actualVer, publicPreview)) {
         core20.exportVariable("CODEQL_ENABLE_EXPERIMENTAL_FEATURES" /* EXPERIMENTAL_FEATURES */, "true");
-        logger.info("Experimental Rust analysis enabled");
+        logger2.info("Experimental Rust analysis enabled");
       }
     }
-    analysisKinds = await getAnalysisKinds(logger, features);
+    analysisKinds = await getAnalysisKinds(logger2, features);
     const debugMode = getOptionalInput("debug") === "true" || core20.isDebug();
     const fileCoverageResult = await getFileCoverageInformationEnabled(
       debugMode,
@@ -159070,7 +159073,7 @@ async function run3(startedAt) {
       features,
       repositoryProperties,
       enableFileCoverageInformation: fileCoverageResult.enabled,
-      logger
+      logger: logger2
     });
     if (config.languages.includes("swift" /* swift */) && process.platform !== "darwin") {
       throw new ConfigurationError(
@@ -159100,7 +159103,7 @@ async function run3(startedAt) {
       );
     }
     if (fileCoverageResult.showDeprecationWarning) {
-      logFileCoverageOnPrsDeprecationWarning(logger);
+      logFileCoverageOnPrsDeprecationWarning(logger2);
     }
     await checkInstallPython311(config.languages, codeql);
   } catch (unwrappedError) {
@@ -159111,8 +159114,8 @@ async function run3(startedAt) {
       error3 instanceof ConfigurationError ? "user-error" : "aborted",
       startedAt,
       config,
-      await checkDiskUsage(logger),
-      logger,
+      await checkDiskUsage(logger2),
+      logger2,
       error3.message,
       error3.stack
     );
@@ -159131,11 +159134,11 @@ async function run3(startedAt) {
           overlayBaseDatabaseStats = await downloadOverlayBaseDatabaseFromCache(
             codeql,
             config,
-            logger
+            logger2
           );
           if (!overlayBaseDatabaseStats) {
             config.overlayDatabaseMode = "none" /* None */;
-            logger.info(
+            logger2.info(
               `No overlay-base database found in cache, reverting overlay database mode to ${"none" /* None */}.`
             );
           }
@@ -159143,7 +159146,7 @@ async function run3(startedAt) {
       );
     }
     if (config.overlayDatabaseMode !== "overlay" /* Overlay */) {
-      cleanupDatabaseClusterDirectory(config, logger);
+      cleanupDatabaseClusterDirectory(config, logger2);
     }
     if (zstdAvailability) {
       await recordZstdAvailability(config, zstdAvailability);
@@ -159173,7 +159176,7 @@ async function run3(startedAt) {
           "indirectTracingSupportsStaticBinaries" /* IndirectTracingSupportsStaticBinaries */
         )) {
           try {
-            logger.debug(`Applying static binary workaround for Go`);
+            logger2.debug(`Applying static binary workaround for Go`);
             const tempBinPath = path24.resolve(
               getTemporaryDirectory(),
               "codeql-action-go-tracing",
@@ -159191,7 +159194,7 @@ exec ${goBinaryPath} "$@"`
             fs28.chmodSync(goWrapperPath, "755");
             core20.exportVariable("CODEQL_ACTION_GO_BINARY" /* GO_BINARY_LOCATION */, goWrapperPath);
           } catch (e) {
-            logger.warning(
+            logger2.warning(
               `Analyzing Go on Linux, but failed to install wrapper script. Tracing custom builds may fail: ${e}`
             );
           }
@@ -159199,7 +159202,7 @@ exec ${goBinaryPath} "$@"`
           core20.exportVariable("CODEQL_ACTION_GO_BINARY" /* GO_BINARY_LOCATION */, goBinaryPath);
         }
       } catch (e) {
-        logger.warning(
+        logger2.warning(
           `Failed to determine the location of the Go binary: ${e}`
         );
         if (e instanceof FileCmdNotFoundError) {
@@ -159225,11 +159228,11 @@ exec ${goBinaryPath} "$@"`
     }
     core20.exportVariable(
       "CODEQL_RAM",
-      process.env["CODEQL_RAM"] || getCodeQLMemoryLimit(getOptionalInput("ram"), logger).toString()
+      process.env["CODEQL_RAM"] || getCodeQLMemoryLimit(getOptionalInput("ram"), logger2).toString()
     );
     core20.exportVariable(
       "CODEQL_THREADS",
-      process.env["CODEQL_THREADS"] || getThreadsFlagValue(getOptionalInput("threads"), logger).toString()
+      process.env["CODEQL_THREADS"] || getThreadsFlagValue(getOptionalInput("threads"), logger2).toString()
     );
     if (await features.getValue("disable_kotlin_analysis_enabled" /* DisableKotlinAnalysisEnabled */)) {
       core20.exportVariable("CODEQL_EXTRACTOR_JAVA_AGENT_DISABLE_KOTLIN", "true");
@@ -159246,23 +159249,23 @@ exec ${goBinaryPath} "$@"`
         codeql,
         features,
         config.languages,
-        logger
+        logger2
       );
       dependencyCachingStatus = dependencyCachingResult.statusReport;
       config.dependencyCachingRestoredKeys = dependencyCachingResult.restoredKeys;
     }
     if (getOptionalInput("setup-python-dependencies") !== void 0) {
-      logger.warning(
+      logger2.warning(
         "The setup-python-dependencies input is deprecated and no longer has any effect. We recommend removing any references from your workflows. See https://github.blog/changelog/2024-01-23-codeql-2-16-python-dependency-installation-disabled-new-queries-and-bug-fixes/ for more information."
       );
     }
     if (process.env["CODEQL_ACTION_DISABLE_PYTHON_DEPENDENCY_INSTALLATION"] !== void 0) {
-      logger.warning(
+      logger2.warning(
         "The CODEQL_ACTION_DISABLE_PYTHON_DEPENDENCY_INSTALLATION environment variable is deprecated and no longer has any effect. We recommend removing any references from your workflows. See https://github.blog/changelog/2024-01-23-codeql-2-16-python-dependency-installation-disabled-new-queries-and-bug-fixes/ for more information."
       );
     }
     if (process.env["CODEQL_EXTRACTOR_JAVA_OPTION_MINIMIZE_DEPENDENCY_JARS" /* JAVA_EXTRACTOR_MINIMIZE_DEPENDENCY_JARS */]) {
-      logger.debug(
+      logger2.debug(
         `${"CODEQL_EXTRACTOR_JAVA_OPTION_MINIMIZE_DEPENDENCY_JARS" /* JAVA_EXTRACTOR_MINIMIZE_DEPENDENCY_JARS */} is already set to '${process.env["CODEQL_EXTRACTOR_JAVA_OPTION_MINIMIZE_DEPENDENCY_JARS" /* JAVA_EXTRACTOR_MINIMIZE_DEPENDENCY_JARS */]}', so the Action will not override it.`
       );
     } else if (await codeQlVersionAtLeast(codeql, CODEQL_VERSION_JAR_MINIMIZATION) && config.dependencyCachingEnabled && config.buildMode === "none" /* None */ && config.languages.includes("java" /* java */)) {
@@ -159274,7 +159277,7 @@ exec ${goBinaryPath} "$@"`
     const { registriesAuthTokens, qlconfigFile } = await generateRegistries(
       getOptionalInput("registries"),
       config.tempDir,
-      logger
+      logger2
     );
     const databaseInitEnvironment = {
       GITHUB_TOKEN: apiDetails.auth,
@@ -159287,14 +159290,14 @@ exec ${goBinaryPath} "$@"`
       sourceRoot,
       "Runner.Worker.exe",
       qlconfigFile,
-      logger
+      logger2
     );
-    if (config.overlayDatabaseMode !== "none" /* None */ && !await checkPacksForOverlayCompatibility(codeql, config, logger)) {
-      logger.info(
+    if (config.overlayDatabaseMode !== "none" /* None */ && !await checkPacksForOverlayCompatibility(codeql, config, logger2)) {
+      logger2.info(
         "Reverting overlay database mode to None due to incompatible packs."
       );
       config.overlayDatabaseMode = "none" /* None */;
-      cleanupDatabaseClusterDirectory(config, logger, {
+      cleanupDatabaseClusterDirectory(config, logger2, {
         disableExistingDirectoryWarning: true
       });
       await runDatabaseInitCluster(
@@ -159304,7 +159307,7 @@ exec ${goBinaryPath} "$@"`
         sourceRoot,
         "Runner.Worker.exe",
         qlconfigFile,
-        logger
+        logger2
       );
     }
     const tracerConfig = await getCombinedTracerConfig(codeql, config);
@@ -159321,7 +159324,7 @@ exec ${goBinaryPath} "$@"`
       );
     }
     flushDiagnostics(config);
-    await saveConfig(config, logger);
+    await saveConfig(config, logger2);
     core20.setOutput("codeql-path", config.codeQLCmd);
     core20.setOutput("codeql-version", (await codeql.getVersion()).version);
   } catch (unwrappedError) {
@@ -159338,7 +159341,7 @@ exec ${goBinaryPath} "$@"`
       toolsVersion,
       overlayBaseDatabaseStats,
       dependencyCachingStatus,
-      logger,
+      logger2,
       error3
     );
     return;
@@ -159355,24 +159358,24 @@ exec ${goBinaryPath} "$@"`
     toolsVersion,
     overlayBaseDatabaseStats,
     dependencyCachingStatus,
-    logger
+    logger2
   );
 }
-async function loadRepositoryProperties(repositoryNwo, logger) {
+async function loadRepositoryProperties(repositoryNwo, logger2) {
   const repositoryOwnerType = github3.context.payload.repository?.owner.type;
-  logger.debug(
+  logger2.debug(
     `Repository owner type is '${repositoryOwnerType ?? "unknown"}'.`
   );
   if (repositoryOwnerType === "User") {
-    logger.debug(
+    logger2.debug(
       "Skipping loading repository properties because the repository is owned by a user and therefore cannot have repository properties."
     );
     return new Success({});
   }
   try {
-    return new Success(await loadPropertiesFromApi(logger, repositoryNwo));
+    return new Success(await loadPropertiesFromApi(logger2, repositoryNwo));
   } catch (error3) {
-    logger.warning(
+    logger2.warning(
       `Failed to load repository properties: ${getErrorMessage(error3)}`
     );
     return new Failure(error3);
@@ -159390,7 +159393,7 @@ async function recordZstdAvailability(config, zstdAvailability) {
 }
 async function runWrapper4() {
   const startedAt = /* @__PURE__ */ new Date();
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   try {
     await run3(startedAt);
   } catch (error3) {
@@ -159399,7 +159402,7 @@ async function runWrapper4() {
       "init" /* Init */,
       startedAt,
       error3,
-      logger
+      logger2
     );
   }
   await checkForTimeout();
@@ -159419,7 +159422,7 @@ function createFailedUploadFailedSarifResult(error3) {
     upload_failed_run_stack_trace: wrappedError.stack
   };
 }
-async function prepareFailedSarif(logger, features, config) {
+async function prepareFailedSarif(logger2, features, config) {
   if (!config.codeQLCmd) {
     return new Failure({
       upload_failed_run_skipped_because: "CodeQL command not found"
@@ -159450,7 +159453,7 @@ async function prepareFailedSarif(logger, features, config) {
     );
     return new Success(result);
   } else {
-    const workflow = await getWorkflow(logger);
+    const workflow = await getWorkflow(logger2);
     const shouldUpload = getUploadInputOrThrow(workflow, jobName, matrix);
     if (!["always", "failure-only"].includes(
       getUploadValue(shouldUpload)
@@ -159483,40 +159486,40 @@ async function generateFailedSarif(features, config, category, checkoutPath, sar
   }
   return { sarifFile, category, checkoutPath };
 }
-async function maybeUploadFailedSarif(config, repositoryNwo, features, logger) {
-  const failedSarifResult = await prepareFailedSarif(logger, features, config);
+async function maybeUploadFailedSarif(config, repositoryNwo, features, logger2) {
+  const failedSarifResult = await prepareFailedSarif(logger2, features, config);
   if (failedSarifResult.isFailure()) {
     return failedSarifResult.value;
   }
   const failedSarif = failedSarifResult.value;
-  logger.info(`Uploading failed SARIF file ${failedSarif.sarifFile}`);
+  logger2.info(`Uploading failed SARIF file ${failedSarif.sarifFile}`);
   const uploadResult = await uploadFiles(
     failedSarif.sarifFile,
     failedSarif.checkoutPath,
     failedSarif.category,
     features,
-    logger,
+    logger2,
     CodeScanning
   );
   await waitForProcessing(
     repositoryNwo,
     uploadResult.sarifID,
-    logger,
+    logger2,
     { isUnsuccessfulExecution: true }
   );
   return uploadResult ? { ...uploadResult.statusReport, sarifID: uploadResult.sarifID } : {};
 }
-async function maybeUploadFailedSarifArtifact(config, features, logger) {
-  const failedSarifResult = await prepareFailedSarif(logger, features, config);
+async function maybeUploadFailedSarifArtifact(config, features, logger2) {
+  const failedSarifResult = await prepareFailedSarif(logger2, features, config);
   if (failedSarifResult.isFailure()) {
     return failedSarifResult.value;
   }
   const failedSarif = failedSarifResult.value;
-  logger.info(
+  logger2.info(
     `Uploading failed SARIF file ${failedSarif.sarifFile} as artifact`
   );
   const gitHubVersion = await getGitHubVersion();
-  const client = await getArtifactUploaderClient(logger, gitHubVersion.type);
+  const client = await getArtifactUploaderClient(logger2, gitHubVersion.type);
   const suffix = getArtifactSuffix(getOptionalInput("matrix"));
   const name = sanitizeArtifactName(`sarif-artifact-${suffix}`);
   await client.uploadArtifact(
@@ -159526,7 +159529,7 @@ async function maybeUploadFailedSarifArtifact(config, features, logger) {
   );
   return { sarifID: name };
 }
-async function tryUploadSarifIfRunFailed(config, repositoryNwo, features, logger) {
+async function tryUploadSarifIfRunFailed(config, repositoryNwo, features, logger2) {
   if (process.env["CODEQL_ACTION_ANALYZE_DID_COMPLETE_SUCCESSFULLY" /* ANALYZE_DID_COMPLETE_SUCCESSFULLY */] === "true") {
     return {
       upload_failed_run_skipped_because: "Analyze Action completed successfully"
@@ -159538,32 +159541,32 @@ async function tryUploadSarifIfRunFailed(config, repositoryNwo, features, logger
         config,
         repositoryNwo,
         features,
-        logger
+        logger2
       );
     } else if (isRiskAssessmentEnabled(config)) {
-      return await maybeUploadFailedSarifArtifact(config, features, logger);
+      return await maybeUploadFailedSarifArtifact(config, features, logger2);
     } else {
       return {
         upload_failed_run_skipped_because: "No analysis kind that supports failed SARIF uploads is enabled."
       };
     }
   } catch (e) {
-    logger.debug(
+    logger2.debug(
       `Failed to upload a SARIF file for this failed CodeQL code scanning run. ${e}`
     );
     return createFailedUploadFailedSarifResult(e);
   }
 }
-async function uploadFailureInfo(uploadAllAvailableDebugArtifacts, printDebugLogs2, codeql, config, repositoryNwo, features, logger) {
-  await recordOverlayStatus(codeql, config, features, logger);
+async function uploadFailureInfo(uploadAllAvailableDebugArtifacts, printDebugLogs2, codeql, config, repositoryNwo, features, logger2) {
+  await recordOverlayStatus(codeql, config, features, logger2);
   const uploadFailedSarifResult = await tryUploadSarifIfRunFailed(
     config,
     repositoryNwo,
     features,
-    logger
+    logger2
   );
   if (uploadFailedSarifResult.upload_failed_run_skipped_because) {
-    logger.debug(
+    logger2.debug(
       `Won't upload a failed SARIF file for this CodeQL analysis because: ${uploadFailedSarifResult.upload_failed_run_skipped_because}.`
     );
   }
@@ -159575,22 +159578,22 @@ async function uploadFailureInfo(uploadAllAvailableDebugArtifacts, printDebugLog
   }
   if (process.env["CODEQL_ACTION_EXPECT_UPLOAD_FAILED_SARIF"] === "true") {
     if (!github4.context.payload.pull_request?.head.repo.fork) {
-      await removeUploadedSarif(uploadFailedSarifResult, logger);
+      await removeUploadedSarif(uploadFailedSarifResult, logger2);
     } else {
-      logger.info(
+      logger2.info(
         "Skipping deletion of failed SARIF because the workflow was triggered from a fork of codeql-action and doesn't have the appropriate permissions for deletion."
       );
     }
   }
   if (config.debugMode) {
-    logger.info(
+    logger2.info(
       "Debug mode is on. Uploading available database bundles and logs as Actions debugging artifacts..."
     );
     const version = await codeql.getVersion();
     await uploadAllAvailableDebugArtifacts(
       codeql,
       config,
-      logger,
+      logger2,
       version.version
     );
     await printDebugLogs2(config);
@@ -159602,22 +159605,22 @@ async function uploadFailureInfo(uploadAllAvailableDebugArtifacts, printDebugLog
         force: true,
         maxRetries: 3
       });
-      logger.info(
+      logger2.info(
         `Cleaned up database cluster directory ${config.dbLocation}.`
       );
     } catch (e) {
-      logger.warning(
+      logger2.warning(
         `Failed to clean up database cluster directory ${config.dbLocation}. Details: ${e}`
       );
     }
   } else {
-    logger.debug(
+    logger2.debug(
       "Skipping cleanup of database cluster directory since we are running on a GitHub-hosted runner which will be automatically cleaned up."
     );
   }
   return uploadFailedSarifResult;
 }
-async function recordOverlayStatus(codeql, config, features, logger) {
+async function recordOverlayStatus(codeql, config, features, logger2) {
   if (config.overlayDatabaseMode !== "overlay-base" /* OverlayBase */ || process.env["CODEQL_ACTION_ANALYZE_DID_COMPLETE_SUCCESSFULLY" /* ANALYZE_DID_COMPLETE_SUCCESSFULLY */] === "true" || !await features.getValue("overlay_analysis_status_save" /* OverlayAnalysisStatusSave */)) {
     return;
   }
@@ -159630,9 +159633,9 @@ async function recordOverlayStatus(codeql, config, features, logger) {
     },
     checkRunId !== void 0 && checkRunId >= 0 ? checkRunId : void 0
   );
-  const diskUsage = await checkDiskUsage(logger);
+  const diskUsage = await checkDiskUsage(logger2);
   if (diskUsage === void 0) {
-    logger.warning(
+    logger2.warning(
       "Unable to save overlay status to the Actions cache because the available disk space could not be determined."
     );
     return;
@@ -159642,24 +159645,24 @@ async function recordOverlayStatus(codeql, config, features, logger) {
     config.languages,
     diskUsage,
     overlayStatus,
-    logger
+    logger2
   );
   const blurb = "This job attempted to run with improved incremental analysis but it did not complete successfully. One possible reason for this is disk space constraints, since improved incremental analysis can require a significant amount of disk space for some repositories.";
   if (saved) {
-    logger.error(
+    logger2.error(
       `${blurb} This failure has been recorded in the Actions cache, so the next CodeQL analysis will run without improved incremental analysis. If you want to enable improved incremental analysis, try increasing the disk space available to the runner. If that doesn't help, contact GitHub Support for further assistance.`
     );
   } else {
-    logger.error(
+    logger2.error(
       `${blurb} The attempt to save this failure status to the Actions cache failed. The Action will attempt to run with improved incremental analysis again.`
     );
   }
 }
-async function removeUploadedSarif(uploadFailedSarifResult, logger) {
+async function removeUploadedSarif(uploadFailedSarifResult, logger2) {
   const sarifID = uploadFailedSarifResult.sarifID;
   if (sarifID) {
-    logger.startGroup("Deleting failed SARIF upload");
-    logger.info(
+    logger2.startGroup("Deleting failed SARIF upload");
+    logger2.info(
       `In test mode, therefore deleting the failed analysis to avoid impacting tool status for the Action repository. SARIF ID to delete: ${sarifID}.`
     );
     const client = getApiClient();
@@ -159676,7 +159679,7 @@ async function removeUploadedSarif(uploadFailedSarifResult, logger) {
       );
       if (analysisInfo.data.length === 1) {
         const analysis = analysisInfo.data[0];
-        logger.info(`Analysis ID to delete: ${analysis.id}.`);
+        logger2.info(`Analysis ID to delete: ${analysis.id}.`);
         try {
           await client.request(
             "DELETE /repos/:owner/:repo/code-scanning/analyses/:analysis_id?confirm_delete",
@@ -159686,7 +159689,7 @@ async function removeUploadedSarif(uploadFailedSarifResult, logger) {
               analysis_id: analysis.id
             }
           );
-          logger.info(`Analysis deleted.`);
+          logger2.info(`Analysis deleted.`);
         } catch (e) {
           const origMessage = getErrorMessage(e);
           const newMessage = origMessage.includes(
@@ -159706,10 +159709,10 @@ async function removeUploadedSarif(uploadFailedSarifResult, logger) {
         )}`
       );
     } finally {
-      logger.endGroup();
+      logger2.endGroup();
     }
   } else {
-    logger.warning(
+    logger2.warning(
       "Could not delete the uploaded SARIF analysis because a SARIF ID wasn't provided by the API when uploading the SARIF file."
     );
   }
@@ -159717,24 +159720,24 @@ async function removeUploadedSarif(uploadFailedSarifResult, logger) {
 
 // src/init-action-post.ts
 async function run4(startedAt) {
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   let config;
   let uploadFailedSarifResult;
   let dependencyCachingUsage;
   try {
     restoreInputs();
     const gitHubVersion = await getGitHubVersion();
-    checkGitHubVersionInRange(gitHubVersion, logger);
+    checkGitHubVersionInRange(gitHubVersion, logger2);
     const repositoryNwo = getRepositoryNwo();
     const features = initFeatures(
       gitHubVersion,
       repositoryNwo,
       getTemporaryDirectory(),
-      logger
+      logger2
     );
-    config = await getConfig(getTemporaryDirectory(), logger);
+    config = await getConfig(getTemporaryDirectory(), logger2);
     if (config === void 0) {
-      logger.warning(
+      logger2.warning(
         "Debugging artifacts are unavailable since the 'init' Action failed before it could produce any."
       );
     } else {
@@ -159746,10 +159749,10 @@ async function run4(startedAt) {
         config,
         repositoryNwo,
         features,
-        logger
+        logger2
       );
       if (await isAnalyzingDefaultBranch() && config.dependencyCachingEnabled !== "none" /* None */) {
-        dependencyCachingUsage = await getDependencyCacheUsage(logger);
+        dependencyCachingUsage = await getDependencyCacheUsage(logger2);
       }
     }
   } catch (unwrappedError) {
@@ -159760,8 +159763,8 @@ async function run4(startedAt) {
       getActionsStatus(error3),
       startedAt,
       config,
-      await checkDiskUsage(logger),
-      logger,
+      await checkDiskUsage(logger2),
+      logger2,
       error3.message,
       error3.stack
     );
@@ -159771,14 +159774,14 @@ async function run4(startedAt) {
     return;
   }
   const jobStatus = getFinalJobStatus(config);
-  logger.info(`CodeQL job status was ${getJobStatusDisplayName(jobStatus)}.`);
+  logger2.info(`CodeQL job status was ${getJobStatusDisplayName(jobStatus)}.`);
   const statusReportBase = await createStatusReportBase(
     "init-post" /* InitPost */,
     "success",
     startedAt,
     config,
-    await checkDiskUsage(logger),
-    logger
+    await checkDiskUsage(logger2),
+    logger2
   );
   if (statusReportBase !== void 0) {
     const statusReport = {
@@ -159787,9 +159790,9 @@ async function run4(startedAt) {
       job_status: jobStatus,
       dependency_caching_usage: dependencyCachingUsage
     };
-    logger.info("Sending status report for init-post step.");
+    logger2.info("Sending status report for init-post step.");
     await sendStatusReport(statusReport);
-    logger.info("Status report sent for init-post step.");
+    logger2.info("Status report sent for init-post step.");
   }
 }
 function getFinalJobStatus(config) {
@@ -159821,7 +159824,7 @@ function getJobStatusFromEnvironment() {
 }
 async function runWrapper5() {
   const startedAt = /* @__PURE__ */ new Date();
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   try {
     await run4(startedAt);
   } catch (error3) {
@@ -159830,7 +159833,7 @@ async function runWrapper5() {
       "init-post" /* InitPost */,
       startedAt,
       error3,
-      logger
+      logger2
     );
   }
 }
@@ -159839,21 +159842,21 @@ async function runWrapper5() {
 var core22 = __toESM(require_core());
 
 // src/resolve-environment.ts
-async function runResolveBuildEnvironment(cmd, logger, workingDir, language) {
-  logger.startGroup(`Attempting to resolve build environment for ${language}`);
+async function runResolveBuildEnvironment(cmd, logger2, workingDir, language) {
+  logger2.startGroup(`Attempting to resolve build environment for ${language}`);
   const codeql = await getCodeQL(cmd);
   if (workingDir !== void 0) {
-    logger.info(`Using ${workingDir} as the working directory.`);
+    logger2.info(`Using ${workingDir} as the working directory.`);
   }
   const result = await codeql.resolveBuildEnvironment(workingDir, language);
-  logger.endGroup();
+  logger2.endGroup();
   return result;
 }
 
 // src/resolve-environment-action.ts
 var ENVIRONMENT_OUTPUT_NAME = "environment";
 async function run5(startedAt) {
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   let config;
   try {
     const statusReportBase2 = await createStatusReportBase(
@@ -159861,16 +159864,16 @@ async function run5(startedAt) {
       "starting",
       startedAt,
       config,
-      await checkDiskUsage(logger),
-      logger
+      await checkDiskUsage(logger2),
+      logger2
     );
     if (statusReportBase2 !== void 0) {
       await sendStatusReport(statusReportBase2);
     }
     const gitHubVersion = await getGitHubVersion();
-    checkGitHubVersionInRange(gitHubVersion, logger);
+    checkGitHubVersionInRange(gitHubVersion, logger2);
     checkActionVersion(getActionVersion(), gitHubVersion);
-    config = await getConfig(getTemporaryDirectory(), logger);
+    config = await getConfig(getTemporaryDirectory(), logger2);
     if (config === void 0) {
       throw new ConfigurationError(
         "Config file could not be found at expected location. Has the 'init' action been called?"
@@ -159879,7 +159882,7 @@ async function run5(startedAt) {
     const workingDirectory = getOptionalInput("working-directory");
     const result = await runResolveBuildEnvironment(
       config.codeQLCmd,
-      logger,
+      logger2,
       workingDirectory,
       getRequiredInput("language")
     );
@@ -159888,7 +159891,7 @@ async function run5(startedAt) {
     const error3 = wrapError(unwrappedError);
     if (error3 instanceof CliError) {
       core22.setOutput(ENVIRONMENT_OUTPUT_NAME, {});
-      logger.warning(
+      logger2.warning(
         `Failed to resolve a build environment suitable for automatically building your code. ${error3.message}`
       );
     } else {
@@ -159900,8 +159903,8 @@ async function run5(startedAt) {
         getActionsStatus(error3),
         startedAt,
         config,
-        await checkDiskUsage(logger),
-        logger,
+        await checkDiskUsage(logger2),
+        logger2,
         error3.message,
         error3.stack
       );
@@ -159916,8 +159919,8 @@ async function run5(startedAt) {
     "success",
     startedAt,
     config,
-    await checkDiskUsage(logger),
-    logger
+    await checkDiskUsage(logger2),
+    logger2
   );
   if (statusReportBase !== void 0) {
     await sendStatusReport(statusReportBase);
@@ -159925,7 +159928,7 @@ async function run5(startedAt) {
 }
 async function runWrapper6() {
   const startedAt = /* @__PURE__ */ new Date();
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   try {
     await run5(startedAt);
   } catch (error3) {
@@ -159938,7 +159941,7 @@ async function runWrapper6() {
       "resolve-environment" /* ResolveEnvironment */,
       startedAt,
       error3,
-      logger
+      logger2
     );
   }
   await checkForTimeout();
@@ -159946,14 +159949,14 @@ async function runWrapper6() {
 
 // src/setup-codeql-action.ts
 var core23 = __toESM(require_core());
-async function sendCompletedStatusReport3(startedAt, toolsDownloadStatusReport, toolsFeatureFlagsValid, toolsSource, toolsVersion, logger, error3) {
+async function sendCompletedStatusReport3(startedAt, toolsDownloadStatusReport, toolsFeatureFlagsValid, toolsSource, toolsVersion, logger2, error3) {
   const statusReportBase = await createStatusReportBase(
     "setup-codeql" /* SetupCodeQL */,
     getActionsStatus(error3),
     startedAt,
     void 0,
-    await checkDiskUsage(logger),
-    logger,
+    await checkDiskUsage(logger2),
+    logger2,
     error3?.message,
     error3?.stack
   );
@@ -159977,7 +159980,7 @@ async function sendCompletedStatusReport3(startedAt, toolsDownloadStatusReport,
   await sendStatusReport({ ...initStatusReport, ...initToolsDownloadFields });
 }
 async function run6(startedAt) {
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   let codeql;
   let toolsDownloadStatusReport;
   let toolsFeatureFlagsValid;
@@ -159992,25 +159995,25 @@ async function run6(startedAt) {
       apiURL: getRequiredEnvParam("GITHUB_API_URL")
     };
     const gitHubVersion = await getGitHubVersion();
-    checkGitHubVersionInRange(gitHubVersion, logger);
+    checkGitHubVersionInRange(gitHubVersion, logger2);
     checkActionVersion(getActionVersion(), gitHubVersion);
     const repositoryNwo = getRepositoryNwo();
     const features = initFeatures(
       gitHubVersion,
       repositoryNwo,
       getTemporaryDirectory(),
-      logger
+      logger2
     );
     const jobRunUuid = v4_default();
-    logger.info(`Job run UUID is ${jobRunUuid}.`);
+    logger2.info(`Job run UUID is ${jobRunUuid}.`);
     core23.exportVariable("JOB_RUN_UUID" /* JOB_RUN_UUID */, jobRunUuid);
     const statusReportBase = await createStatusReportBase(
       "setup-codeql" /* SetupCodeQL */,
       "starting",
       startedAt,
       void 0,
-      await checkDiskUsage(logger),
-      logger
+      await checkDiskUsage(logger2),
+      logger2
     );
     if (statusReportBase !== void 0) {
       await sendStatusReport(statusReportBase);
@@ -160020,7 +160023,7 @@ async function run6(startedAt) {
     const rawLanguages = getRawLanguagesNoAutodetect(
       getOptionalInput("languages")
     );
-    const analysisKinds = await getAnalysisKinds(logger, features);
+    const analysisKinds = await getAnalysisKinds(logger2, features);
     const initCodeQLResult = await initCodeQL(
       getOptionalInput("tools"),
       apiDetails,
@@ -160030,7 +160033,7 @@ async function run6(startedAt) {
       rawLanguages,
       analysisKinds.length === 1 && analysisKinds[0] === "code-scanning" /* CodeScanning */,
       features,
-      logger
+      logger2
     );
     codeql = initCodeQLResult.codeql;
     toolsDownloadStatusReport = initCodeQLResult.toolsDownloadStatusReport;
@@ -160047,8 +160050,8 @@ async function run6(startedAt) {
       error3 instanceof ConfigurationError ? "user-error" : "failure",
       startedAt,
       void 0,
-      await checkDiskUsage(logger),
-      logger,
+      await checkDiskUsage(logger2),
+      logger2,
       error3.message,
       error3.stack
     );
@@ -160063,12 +160066,12 @@ async function run6(startedAt) {
     toolsFeatureFlagsValid,
     toolsSource,
     toolsVersion,
-    logger
+    logger2
   );
 }
 async function runWrapper7() {
   const startedAt = /* @__PURE__ */ new Date();
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   try {
     await run6(startedAt);
   } catch (error3) {
@@ -160077,7 +160080,7 @@ async function runWrapper7() {
       "setup-codeql" /* SetupCodeQL */,
       startedAt,
       error3,
-      logger
+      logger2
     );
   }
   await checkForTimeout();
@@ -160287,14 +160290,14 @@ var StartProxyError = class extends Error {
     this.errorType = errorType;
   }
 };
-async function sendSuccessStatusReport(startedAt, config, registry_types, logger) {
+async function sendSuccessStatusReport(startedAt, config, registry_types, logger2) {
   const statusReportBase = await createStatusReportBase(
     "start-proxy" /* StartProxy */,
     "success",
     startedAt,
     config,
-    await checkDiskUsage(logger),
-    logger
+    await checkDiskUsage(logger2),
+    logger2
   );
   if (statusReportBase !== void 0) {
     const statusReport = {
@@ -160310,7 +160313,7 @@ function getSafeErrorMessage(error3) {
   }
   return `Error from start-proxy Action omitted (${error3.constructor.name}).`;
 }
-async function sendFailedStatusReport(logger, startedAt, language, unwrappedError) {
+async function sendFailedStatusReport(logger2, startedAt, language, unwrappedError) {
   const error3 = wrapError(unwrappedError);
   core25.setFailed(`start-proxy action failed: ${error3.message}`);
   const statusReportMessage = getSafeErrorMessage(error3);
@@ -160321,8 +160324,8 @@ async function sendFailedStatusReport(logger, startedAt, language, unwrappedErro
     {
       languages: language === void 0 ? void 0 : [language]
     },
-    await checkDiskUsage(logger),
-    logger,
+    await checkDiskUsage(logger2),
+    logger2,
     statusReportMessage
   );
   if (errorStatusReportBase !== void 0) {
@@ -160367,24 +160370,24 @@ function getRegistryAddress(registry) {
     );
   }
 }
-function getCredentials(logger, registrySecrets, registriesCredentials, language) {
+function getCredentials(logger2, registrySecrets, registriesCredentials, language) {
   const registryTypeForLanguage = language ? LANGUAGE_TO_REGISTRY_TYPE[language] : void 0;
   let credentialsStr;
   if (registriesCredentials !== void 0) {
-    logger.info(`Using registries_credentials input.`);
+    logger2.info(`Using registries_credentials input.`);
     credentialsStr = Buffer.from(registriesCredentials, "base64").toString();
   } else if (registrySecrets !== void 0) {
-    logger.info(`Using registry_secrets input.`);
+    logger2.info(`Using registry_secrets input.`);
     credentialsStr = registrySecrets;
   } else {
-    logger.info(`No credentials defined.`);
+    logger2.info(`No credentials defined.`);
     return [];
   }
   let parsed;
   try {
     parsed = parseString(credentialsStr);
   } catch {
-    logger.error("Failed to parse the credentials data.");
+    logger2.error("Failed to parse the credentials data.");
     throw new ConfigurationError("Invalid credentials format.");
   }
   if (!isArray(parsed)) {
@@ -160420,7 +160423,7 @@ function getCredentials(logger, registrySecrets, registriesCredentials, language
     const passwordIsPAT = hasUsernameAndPassword(authConfig) && isDefined2(authConfig.password) && isPAT(authConfig.password);
     const tokenIsPAT = hasToken(authConfig) && isDefined2(authConfig.token) && isPAT(authConfig.token);
     if (noUsername && (passwordIsPAT || tokenIsPAT)) {
-      logger.warning(
+      logger2.warning(
         `A ${e.type} private registry is configured for ${e.host || e.url} using a GitHub Personal Access Token (PAT), but no username was provided. This may not work correctly. When configuring a private registry using a PAT, select "Username and password" and enter the username of the user who generated the PAT.`
       );
     }
@@ -160460,7 +160463,7 @@ async function getCliVersionFromFeatures(features) {
   const gitHubVersion = await getGitHubVersion();
   return await features.getEnabledDefaultCliVersions(gitHubVersion.type);
 }
-async function getDownloadUrl(logger, features) {
+async function getDownloadUrl(logger2, features) {
   const proxyPackage = getProxyPackage();
   try {
     const useFeaturesToDetermineCLI = await features.getValue(
@@ -160473,7 +160476,7 @@ async function getDownloadUrl(logger, features) {
     const cliRelease = await getReleaseByVersion(versionInfo.tagName);
     for (const asset of cliRelease.data.assets) {
       if (asset.name === proxyPackage) {
-        logger.info(
+        logger2.info(
           `Found '${proxyPackage}' in release '${versionInfo.tagName}' at '${asset.url}'`
         );
         return {
@@ -160486,11 +160489,11 @@ async function getDownloadUrl(logger, features) {
       }
     }
   } catch (ex) {
-    logger.warning(
+    logger2.warning(
       `Failed to retrieve information about the linked release: ${getErrorMessage(ex)}`
     );
   }
-  logger.info(
+  logger2.info(
     `Did not find '${proxyPackage}' in the linked release, falling back to hard-coded version.`
   );
   return {
@@ -160498,7 +160501,7 @@ async function getDownloadUrl(logger, features) {
     version: UPDATEJOB_PROXY_VERSION
   };
 }
-async function downloadProxy(logger, url2, authorization) {
+async function downloadProxy(logger2, url2, authorization) {
   try {
     return toolcache4.downloadTool(
       url2,
@@ -160510,27 +160513,27 @@ async function downloadProxy(logger, url2, authorization) {
       }
     );
   } catch (error3) {
-    logger.error(
+    logger2.error(
       `Failed to download proxy archive from ${url2}: ${getErrorMessage(error3)}`
     );
     throw new StartProxyError(0 /* DownloadFailed */);
   }
 }
-async function extractProxy(logger, archive) {
+async function extractProxy(logger2, archive) {
   try {
     return await toolcache4.extractTar(archive);
   } catch (error3) {
-    logger.error(
+    logger2.error(
       `Failed to extract proxy archive from ${archive}: ${getErrorMessage(error3)}`
     );
     throw new StartProxyError(1 /* ExtractionFailed */);
   }
 }
-async function cacheProxy(logger, source, filename, version) {
+async function cacheProxy(logger2, source, filename, version) {
   try {
     return await toolcache4.cacheDir(source, filename, version);
   } catch (error3) {
-    logger.error(
+    logger2.error(
       `Failed to add proxy archive from ${source} to toolcache: ${getErrorMessage(error3)}`
     );
     throw new StartProxyError(2 /* CacheFailed */);
@@ -160539,21 +160542,21 @@ async function cacheProxy(logger, source, filename, version) {
 function getProxyFilename() {
   return process.platform === "win32" ? `${UPDATEJOB_PROXY}.exe` : UPDATEJOB_PROXY;
 }
-async function getProxyBinaryPath(logger, features) {
+async function getProxyBinaryPath(logger2, features) {
   const proxyFileName = getProxyFilename();
-  const proxyInfo = await getDownloadUrl(logger, features);
+  const proxyInfo = await getDownloadUrl(logger2, features);
   let proxyBin = toolcache4.find(proxyFileName, proxyInfo.version);
   if (!proxyBin) {
     const apiDetails = getApiDetails();
     const authorization = getAuthorizationHeaderFor(
-      logger,
+      logger2,
       apiDetails,
       proxyInfo.url
     );
-    const temp = await downloadProxy(logger, proxyInfo.url, authorization);
-    const extracted = await extractProxy(logger, temp);
+    const temp = await downloadProxy(logger2, proxyInfo.url, authorization);
+    const extracted = await extractProxy(logger2, temp);
     proxyBin = await cacheProxy(
-      logger,
+      logger2,
       extracted,
       proxyFileName,
       proxyInfo.version
@@ -160628,20 +160631,20 @@ var fs30 = __toESM(require("fs"));
 var path27 = __toESM(require("path"));
 var toolrunner5 = __toESM(require_toolrunner());
 var io8 = __toESM(require_io());
-function checkEnvVar(logger, name) {
+function checkEnvVar(logger2, name) {
   const value = process.env[name];
   if (isDefined2(value)) {
     const url2 = URL.parse(value);
     if (isDefined2(url2)) {
       url2.username = "";
       url2.password = "";
-      logger.info(`Environment variable '${name}' is set to '${url2}'.`);
+      logger2.info(`Environment variable '${name}' is set to '${url2}'.`);
     } else {
-      logger.info(`Environment variable '${name}' is set to '${value}'.`);
+      logger2.info(`Environment variable '${name}' is set to '${value}'.`);
     }
     return true;
   } else {
-    logger.debug(`Environment variable '${name}' is not set.`);
+    logger2.debug(`Environment variable '${name}' is not set.`);
     return false;
   }
 }
@@ -160669,9 +160672,9 @@ var JAVA_PROXY_ENV_VARS = [
   "JDK_JAVA_OPTIONS" /* JDK_JAVA_OPTIONS */,
   "_JAVA_OPTIONS" /* _JAVA_OPTIONS */
 ];
-function checkJavaEnvVars(logger) {
+function checkJavaEnvVars(logger2) {
   for (const envVar of JAVA_PROXY_ENV_VARS) {
-    checkEnvVar(logger, envVar);
+    checkEnvVar(logger2, envVar);
   }
 }
 function discoverActionsJdks() {
@@ -160687,7 +160690,7 @@ function discoverActionsJdks() {
   }
   return paths;
 }
-function checkJdkSettings(logger, jdkHome) {
+function checkJdkSettings(logger2, jdkHome) {
   const filesToCheck = [
     // JDK 9+
     path27.join("conf", "net.properties"),
@@ -160698,24 +160701,24 @@ function checkJdkSettings(logger, jdkHome) {
     const file = path27.join(jdkHome, fileToCheck);
     try {
       if (fs30.existsSync(file)) {
-        logger.debug(`Found '${file}'.`);
+        logger2.debug(`Found '${file}'.`);
         const lines = String(fs30.readFileSync(file)).split("\n");
         for (const line of lines) {
           for (const property of javaProperties) {
             if (line.startsWith(`${property}=`)) {
-              logger.info(`Found '${line.trimEnd()}' in '${file}'.`);
+              logger2.info(`Found '${line.trimEnd()}' in '${file}'.`);
             }
           }
         }
       } else {
-        logger.debug(`'${file}' does not exist.`);
+        logger2.debug(`'${file}' does not exist.`);
       }
     } catch (err) {
-      logger.debug(`Failed to read '${file}': ${getErrorMessage(err)}`);
+      logger2.debug(`Failed to read '${file}': ${getErrorMessage(err)}`);
     }
   }
 }
-async function showJavaSettings(logger) {
+async function showJavaSettings(logger2) {
   try {
     const java = await io8.which("java", true);
     let output = "";
@@ -160734,11 +160737,11 @@ async function showJavaSettings(logger) {
         }
       }
     ).exec();
-    logger.startGroup("Java settings");
-    logger.info(output);
-    logger.endGroup();
+    logger2.startGroup("Java settings");
+    logger2.info(output);
+    logger2.endGroup();
   } catch (err) {
-    logger.debug(`Failed to query java settings: ${getErrorMessage(err)}`);
+    logger2.debug(`Failed to query java settings: ${getErrorMessage(err)}`);
   }
 }
 var ProxyEnvVars = /* @__PURE__ */ ((ProxyEnvVars2) => {
@@ -160747,20 +160750,20 @@ var ProxyEnvVars = /* @__PURE__ */ ((ProxyEnvVars2) => {
   ProxyEnvVars2["ALL_PROXY"] = "ALL_PROXY";
   return ProxyEnvVars2;
 })(ProxyEnvVars || {});
-function checkProxyEnvVars(logger) {
+function checkProxyEnvVars(logger2) {
   for (const envVar of Object.values(ProxyEnvVars)) {
-    checkEnvVar(logger, envVar);
-    checkEnvVar(logger, envVar.toLowerCase());
+    checkEnvVar(logger2, envVar);
+    checkEnvVar(logger2, envVar.toLowerCase());
   }
 }
-async function checkProxyEnvironment(logger, language) {
-  checkProxyEnvVars(logger);
+async function checkProxyEnvironment(logger2, language) {
+  checkProxyEnvVars(logger2);
   if (language === void 0 || language === "java" /* java */) {
-    checkJavaEnvVars(logger);
-    await showJavaSettings(logger);
+    checkJavaEnvVars(logger2);
+    await showJavaSettings(logger2);
     const jdks = discoverActionsJdks();
     for (const jdk of jdks) {
-      checkJdkSettings(logger, jdk);
+      checkJdkSettings(logger2, jdk);
     }
   }
 }
@@ -160825,11 +160828,11 @@ var NetworkReachabilityBackend = class {
     });
   }
 };
-async function checkConnections(logger, proxy, backend) {
+async function checkConnections(logger2, proxy, backend) {
   const result = /* @__PURE__ */ new Set();
   if (proxy.registries.length === 0) return result;
-  logger.startGroup("Testing connections via the proxy");
-  logger.info(
+  logger2.startGroup("Testing connections via the proxy");
+  logger2.info(
     `The connection tests performed here are best-effort only and failures here may not affect the subsequent analysis. See ${"https://docs.github.com/en/code-security/reference/code-scanning/code-scanning-logs#diagnostic-information-for-private-package-registries" /* PRIVATE_REGISTRY_LOGS */} for more information.`
   );
   try {
@@ -160841,40 +160844,40 @@ async function checkConnections(logger, proxy, backend) {
       const address = getAddressString(registry);
       const url2 = URL.parse(address);
       if (url2 === null) {
-        logger.info(
+        logger2.info(
           `Skipping check for ${address} since it is not a valid URL.`
         );
         continue;
       }
       const testUrl = makeTestUrl(config, url2);
       try {
-        logger.debug(`Testing connection to ${url2}...`);
+        logger2.debug(`Testing connection to ${url2}...`);
         const statusCode = await backend.checkConnection(testUrl);
-        logger.info(`Successfully tested connection to ${url2} (${statusCode})`);
+        logger2.info(`Successfully tested connection to ${url2} (${statusCode})`);
         result.add(registry);
       } catch (e) {
         if (e instanceof ReachabilityError && e.statusCode !== void 0) {
-          logger.info(`Connection test to ${url2} failed. (${e.statusCode})`);
+          logger2.info(`Connection test to ${url2} failed. (${e.statusCode})`);
         } else {
-          logger.warning(
+          logger2.warning(
             `Connection test to ${url2} failed: ${getErrorMessage(e)}`
           );
         }
       }
     }
-    logger.debug(`Finished testing connections to private registries.`);
+    logger2.debug(`Finished testing connections to private registries.`);
   } catch (e) {
-    logger.warning(
+    logger2.warning(
       `Failed to test connections to private registries: ${getErrorMessage(e)}`
     );
   }
-  logger.endGroup();
+  logger2.endGroup();
   return result;
 }
 
 // src/start-proxy-action.ts
 async function run7(startedAt) {
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   let features;
   let language;
   try {
@@ -160888,29 +160891,29 @@ async function run7(startedAt) {
       gitHubVersion,
       repositoryNwo,
       getTemporaryDirectory(),
-      logger
+      logger2
     );
     const languageInput = getOptionalInput("language");
     language = languageInput ? parseBuiltInLanguage(languageInput) : void 0;
     const credentials = getCredentials(
-      logger,
+      logger2,
       getOptionalInput("registry_secrets"),
       getOptionalInput("registries_credentials"),
       language
     );
     if (credentials.length === 0) {
-      logger.info("No credentials found, skipping proxy setup.");
+      logger2.info("No credentials found, skipping proxy setup.");
       return;
     }
-    logger.info(
+    logger2.info(
       `Credentials loaded for the following registries:
  ${credentials.map((c) => credentialToStr(c)).join("\n")}`
     );
     if (core26.isDebug() || isInTestMode()) {
       try {
-        await checkProxyEnvironment(logger, language);
+        await checkProxyEnvironment(logger2, language);
       } catch (err) {
-        logger.debug(
+        logger2.debug(
           `Unable to inspect runner environment: ${getErrorMessage(err)}`
         );
       }
@@ -160920,29 +160923,29 @@ async function run7(startedAt) {
       all_credentials: credentials,
       ca
     };
-    const proxyBin = await getProxyBinaryPath(logger, features);
+    const proxyBin = await getProxyBinaryPath(logger2, features);
     const proxyInfo = await startProxy(
       proxyBin,
       proxyConfig,
       proxyLogFilePath,
-      logger
+      logger2
     );
-    await checkConnections(logger, proxyInfo);
+    await checkConnections(logger2, proxyInfo);
     await sendSuccessStatusReport(
       startedAt,
       {
         languages: language === void 0 ? void 0 : [language]
       },
       proxyConfig.all_credentials.map((c) => c.type),
-      logger
+      logger2
     );
   } catch (unwrappedError) {
-    await sendFailedStatusReport(logger, startedAt, language, unwrappedError);
+    await sendFailedStatusReport(logger2, startedAt, language, unwrappedError);
   }
 }
 async function runWrapper8() {
   const startedAt = /* @__PURE__ */ new Date();
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   try {
     await run7(startedAt);
   } catch (error3) {
@@ -160951,11 +160954,11 @@ async function runWrapper8() {
       "start-proxy" /* StartProxy */,
       startedAt,
       getSafeErrorMessage(wrapError(error3)),
-      logger
+      logger2
     );
   }
 }
-async function startProxy(binPath, config, logFilePath, logger) {
+async function startProxy(binPath, config, logFilePath, logger2) {
   const host = "127.0.0.1";
   let port = 49152;
   let subprocess = void 0;
@@ -160990,7 +160993,7 @@ async function startProxy(binPath, config, logFilePath, logger) {
   if (subprocessError) {
     throw subprocessError;
   }
-  logger.info(`Proxy started on ${host}:${port}`);
+  logger2.info(`Proxy started on ${host}:${port}`);
   core26.setOutput("proxy_host", host);
   core26.setOutput("proxy_port", port.toString());
   core26.setOutput("proxy_ca_certificate", config.ca.cert);
@@ -161006,7 +161009,7 @@ async function startProxy(binPath, config, logFilePath, logger) {
 // src/start-proxy-action-post.ts
 var core27 = __toESM(require_core());
 async function runWrapper9() {
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   try {
     restoreInputs();
     const pid = core27.getState("proxy-process-pid");
@@ -161015,23 +161018,23 @@ async function runWrapper9() {
     }
     const config = await getConfig(
       getTemporaryDirectory(),
-      logger
+      logger2
     );
     if (config?.debugMode || core27.isDebug()) {
       const logFilePath = core27.getState("proxy-log-file");
-      logger.info(
+      logger2.info(
         "Debug mode is on. Uploading proxy log as Actions debugging artifact..."
       );
       if (config?.gitHubVersion.type === void 0) {
-        logger.warning(
+        logger2.warning(
           `Did not upload debug artifacts because cannot determine the GitHub variant running.`
         );
         return;
       }
       const gitHubVersion = await getGitHubVersion();
-      checkGitHubVersionInRange(gitHubVersion, logger);
+      checkGitHubVersionInRange(gitHubVersion, logger2);
       await uploadArtifacts(
-        logger,
+        logger2,
         [logFilePath],
         getTemporaryDirectory(),
         "proxy-log-file",
@@ -161039,7 +161042,7 @@ async function runWrapper9() {
       );
     }
   } catch (error3) {
-    logger.warning(
+    logger2.warning(
       `start-proxy post-action step failed: ${getErrorMessage(error3)}`
     );
   }
@@ -161047,14 +161050,14 @@ async function runWrapper9() {
 
 // src/upload-sarif-action.ts
 var core28 = __toESM(require_core());
-async function sendSuccessStatusReport2(startedAt, uploadStats, logger) {
+async function sendSuccessStatusReport2(startedAt, uploadStats, logger2) {
   const statusReportBase = await createStatusReportBase(
     "upload-sarif" /* UploadSarif */,
     "success",
     startedAt,
     void 0,
-    await checkDiskUsage(logger),
-    logger
+    await checkDiskUsage(logger2),
+    logger2
   );
   if (statusReportBase !== void 0) {
     const statusReport = {
@@ -161065,7 +161068,7 @@ async function sendSuccessStatusReport2(startedAt, uploadStats, logger) {
   }
 }
 async function run8(startedAt) {
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   try {
     initializeEnvironment(getActionVersion());
     const gitHubVersion = await getGitHubVersion();
@@ -161076,15 +161079,15 @@ async function run8(startedAt) {
       gitHubVersion,
       repositoryNwo,
       getTemporaryDirectory(),
-      logger
+      logger2
     );
     const startingStatusReportBase = await createStatusReportBase(
       "upload-sarif" /* UploadSarif */,
       "starting",
       startedAt,
       void 0,
-      await checkDiskUsage(logger),
-      logger
+      await checkDiskUsage(logger2),
+      logger2
     );
     if (startingStatusReportBase !== void 0) {
       await sendStatusReport(startingStatusReportBase);
@@ -161093,7 +161096,7 @@ async function run8(startedAt) {
     const checkoutPath = getRequiredInput("checkout_path");
     const category = getOptionalInput("category");
     const uploadResults = await postProcessAndUploadSarif(
-      logger,
+      logger2,
       features,
       "always",
       checkoutPath,
@@ -161119,14 +161122,14 @@ async function run8(startedAt) {
         await waitForProcessing(
           getRepositoryNwo(),
           codeScanningResult.sarifID,
-          logger
+          logger2
         );
       }
     }
     await sendSuccessStatusReport2(
       startedAt,
       codeScanningResult?.statusReport || {},
-      logger
+      logger2
     );
   } catch (unwrappedError) {
     const error3 = isThirdPartyAnalysis("upload-sarif" /* UploadSarif */) && unwrappedError instanceof InvalidSarifUploadError ? new ConfigurationError(unwrappedError.message) : wrapError(unwrappedError);
@@ -161137,8 +161140,8 @@ async function run8(startedAt) {
       getActionsStatus(error3),
       startedAt,
       void 0,
-      await checkDiskUsage(logger),
-      logger,
+      await checkDiskUsage(logger2),
+      logger2,
       message,
       error3.stack
     );
@@ -161150,7 +161153,7 @@ async function run8(startedAt) {
 }
 async function runWrapper10() {
   const startedAt = /* @__PURE__ */ new Date();
-  const logger = getActionsLogger();
+  const logger2 = getActionsLogger();
   try {
     await run8(startedAt);
   } catch (error3) {
@@ -161161,7 +161164,7 @@ async function runWrapper10() {
       "upload-sarif" /* UploadSarif */,
       startedAt,
       error3,
-      logger
+      logger2
     );
   }
 }
@@ -161171,9 +161174,9 @@ var core29 = __toESM(require_core());
 async function runWrapper11() {
   try {
     restoreInputs();
-    const logger = getActionsLogger();
+    const logger2 = getActionsLogger();
     const gitHubVersion = await getGitHubVersion();
-    checkGitHubVersionInRange(gitHubVersion, logger);
+    checkGitHubVersionInRange(gitHubVersion, logger2);
     if (process.env["CODEQL_ACTION_INIT_HAS_RUN" /* INIT_ACTION_HAS_RUN */] !== "true") {
       if (gitHubVersion.type === void 0) {
         core29.warning(
@@ -161184,7 +161187,7 @@ async function runWrapper11() {
       await withGroup(
         "Uploading combined SARIF debug artifact",
         () => uploadCombinedSarifArtifacts(
-          logger,
+          logger2,
           gitHubVersion.type,
           // The codeqlVersion is not applicable for uploading non-codeql sarif.
           // We can assume all versions are safe to upload.
diff --git a/src/cache.ts b/src/cache.ts
index ca766bf74..f9f3afb6e 100644
--- a/src/cache.ts
+++ b/src/cache.ts
@@ -3,6 +3,7 @@ import * as path from "path";
 
 import { getTemporaryDirectory } from "./actions-util";
 import * as json from "./json";
+import { getActionsLogger } from "./logging";
 
 /**
  * The name of the temporary file that backs the on-disk cache of
@@ -37,6 +38,7 @@ interface CommandCacheEntry {
  * (tier 3).
  */
 const inMemoryCache = new Map<CommandCacheKey, CommandCacheEntry>();
+const logger = getActionsLogger();
 
 function getCommandCacheFilePath(): string {
   return path.join(getTemporaryDirectory(), COMMAND_CACHE_FILENAME);
@@ -56,8 +58,8 @@ function readCommandCacheFile(): Record<string, CommandCacheEntry> {
     if (json.isObject(parsed)) {
       return parsed;
     }
-  } catch {
-    // Fall through and treat a malformed file as empty.
+  } catch (e) {
+    logger.warning(`Failed to read or parse command cache file: ${e}`);
   }
   return {};
 }
@@ -69,8 +71,8 @@ function readCommandCacheFile(): Record<string, CommandCacheEntry> {
 function writeCommandCacheFile(data: Record<string, CommandCacheEntry>): void {
   try {
     fs.writeFileSync(getCommandCacheFilePath(), JSON.stringify(data));
-  } catch {
-    // Best-effort; ignore write failures.
+  } catch (e) {
+    logger.warning(`Failed to write command cache file: ${e}`);
   }
 }