@coana-tech/cli 14.12.145 → 14.12.148

package/reachability-analyzers-cli.mjs

@@ -4287,7 +4287,7 @@ var require_safe_stable_stringify = __commonJS({
               return circularValue;
             }
             let res = "";
-            let join18 = ",";
+            let join19 = ",";
             const originalIndentation = indentation;
             if (Array.isArray(value2)) {
               if (value2.length === 0) {
@@ -4301,7 +4301,7 @@ var require_safe_stable_stringify = __commonJS({
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join18 = `,
+                join19 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value2.length, maximumBreadth);
@@ -4309,13 +4309,13 @@ ${indentation}`;
               for (; i4 < maximumValuesToStringify - 1; i4++) {
                 const tmp2 = stringifyFnReplacer(String(i4), value2, stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join18;
+                res += join19;
               }
               const tmp = stringifyFnReplacer(String(i4), value2, stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value2.length - 1 > maximumBreadth) {
                 const removedKeys = value2.length - maximumBreadth - 1;
-                res += `${join18}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join19}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -4336,7 +4336,7 @@ ${originalIndentation}`;
             let separator = "";
             if (spacer !== "") {
               indentation += spacer;
-              join18 = `,
+              join19 = `,
 ${indentation}`;
               whitespace2 = " ";
             }
@@ -4350,13 +4350,13 @@ ${indentation}`;
               const tmp = stringifyFnReplacer(key2, value2, stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace2}${tmp}`;
-                separator = join18;
+                separator = join19;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...":${whitespace2}"${getItemCount(removedKeys)} not stringified"`;
-              separator = join18;
+              separator = join19;
             }
             if (spacer !== "" && separator.length > 1) {
               res = `
@@ -4397,7 +4397,7 @@ ${originalIndentation}`;
             }
             const originalIndentation = indentation;
             let res = "";
-            let join18 = ",";
+            let join19 = ",";
             if (Array.isArray(value2)) {
               if (value2.length === 0) {
                 return "[]";
@@ -4410,7 +4410,7 @@ ${originalIndentation}`;
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join18 = `,
+                join19 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value2.length, maximumBreadth);
@@ -4418,13 +4418,13 @@ ${indentation}`;
               for (; i4 < maximumValuesToStringify - 1; i4++) {
                 const tmp2 = stringifyArrayReplacer(String(i4), value2[i4], stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join18;
+                res += join19;
               }
               const tmp = stringifyArrayReplacer(String(i4), value2[i4], stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value2.length - 1 > maximumBreadth) {
                 const removedKeys = value2.length - maximumBreadth - 1;
-                res += `${join18}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join19}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -4437,7 +4437,7 @@ ${originalIndentation}`;
             let whitespace2 = "";
             if (spacer !== "") {
               indentation += spacer;
-              join18 = `,
+              join19 = `,
 ${indentation}`;
               whitespace2 = " ";
             }
@@ -4446,7 +4446,7 @@ ${indentation}`;
               const tmp = stringifyArrayReplacer(key2, value2[key2], stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace2}${tmp}`;
-                separator = join18;
+                separator = join19;
               }
             }
             if (spacer !== "" && separator.length > 1) {
@@ -4504,20 +4504,20 @@ ${originalIndentation}`;
               indentation += spacer;
               let res2 = `
 ${indentation}`;
-              const join19 = `,
+              const join20 = `,
 ${indentation}`;
               const maximumValuesToStringify = Math.min(value2.length, maximumBreadth);
               let i4 = 0;
               for (; i4 < maximumValuesToStringify - 1; i4++) {
                 const tmp2 = stringifyIndent(String(i4), value2[i4], stack, spacer, indentation);
                 res2 += tmp2 !== void 0 ? tmp2 : "null";
-                res2 += join19;
+                res2 += join20;
               }
               const tmp = stringifyIndent(String(i4), value2[i4], stack, spacer, indentation);
               res2 += tmp !== void 0 ? tmp : "null";
               if (value2.length - 1 > maximumBreadth) {
                 const removedKeys = value2.length - maximumBreadth - 1;
-                res2 += `${join19}"... ${getItemCount(removedKeys)} not stringified"`;
+                res2 += `${join20}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               res2 += `
 ${originalIndentation}`;
@@ -4533,16 +4533,16 @@ ${originalIndentation}`;
               return '"[Object]"';
             }
             indentation += spacer;
-            const join18 = `,
+            const join19 = `,
 ${indentation}`;
             let res = "";
             let separator = "";
             let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
             if (isTypedArrayWithEntries(value2)) {
-              res += stringifyTypedArray(value2, join18, maximumBreadth);
+              res += stringifyTypedArray(value2, join19, maximumBreadth);
               keys = keys.slice(value2.length);
               maximumPropertiesToStringify -= value2.length;
-              separator = join18;
+              separator = join19;
             }
             if (deterministic) {
               keys = insertSort(keys);
@@ -4553,13 +4553,13 @@ ${indentation}`;
               const tmp = stringifyIndent(key2, value2[key2], stack, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}: ${tmp}`;
-                separator = join18;
+                separator = join19;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-              separator = join18;
+              separator = join19;
             }
             if (separator !== "") {
               res = `
@@ -6126,7 +6126,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join18(s2) {
+        value: function join19(s2) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -17210,7 +17210,7 @@ var require_lodash = __commonJS({
           }
           return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : [];
         });
-        function join18(array, separator) {
+        function join19(array, separator) {
           return array == null ? "" : nativeJoin.call(array, separator);
         }
         function last2(array) {
@@ -19129,7 +19129,7 @@ var require_lodash = __commonJS({
         lodash23.isUndefined = isUndefined2;
         lodash23.isWeakMap = isWeakMap;
         lodash23.isWeakSet = isWeakSet;
-        lodash23.join = join18;
+        lodash23.join = join19;
         lodash23.kebabCase = kebabCase;
         lodash23.last = last2;
         lodash23.lastIndexOf = lastIndexOf;
@@ -54200,7 +54200,7 @@ var require_summary = __commonJS({
     exports.summary = exports.markdownSummary = exports.SUMMARY_DOCS_URL = exports.SUMMARY_ENV_VAR = void 0;
     var os_1 = __require("os");
     var fs_1 = __require("fs");
-    var { access: access3, appendFile, writeFile: writeFile10 } = fs_1.promises;
+    var { access: access3, appendFile, writeFile: writeFile11 } = fs_1.promises;
     exports.SUMMARY_ENV_VAR = "GITHUB_STEP_SUMMARY";
     exports.SUMMARY_DOCS_URL = "https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary";
     var Summary = class {
@@ -54258,7 +54258,7 @@ var require_summary = __commonJS({
         return __awaiter(this, void 0, void 0, function* () {
           const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite);
           const filePath = yield this.filePath();
-          const writeFunc = overwrite ? writeFile10 : appendFile;
+          const writeFunc = overwrite ? writeFile11 : appendFile;
           yield writeFunc(filePath, this._buffer, { encoding: "utf8" });
           return this.emptyBuffer();
         });
@@ -72767,8 +72767,8 @@ var require_adm_zip = __commonJS({
         return null;
       }
       function fixPath(zipPath) {
-        const { join: join18, normalize: normalize3, sep: sep6 } = pth.posix;
-        return join18(".", normalize3(sep6 + zipPath.split("\\").join(sep6) + sep6));
+        const { join: join19, normalize: normalize3, sep: sep6 } = pth.posix;
+        return join19(".", normalize3(sep6 + zipPath.split("\\").join(sep6) + sep6));
       }
       function filenameFilter(filterfn) {
         if (filterfn instanceof RegExp) {
@@ -75394,7 +75394,7 @@ var {
 } = import_index.default;
 
 // dist/reachability-analyzers-cli.js
-import { readFile as readFile14, writeFile as writeFile9 } from "fs/promises";
+import { readFile as readFile14, writeFile as writeFile10 } from "fs/promises";
 
 // ../web-compat-utils/src/logger-singleton.ts
 var import_winston = __toESM(require_winston(), 1);
@@ -80667,6 +80667,18 @@ async function sendTelemetrySocket(analysisMetadataId, telemetry) {
     console.warn("Failed to send telemetry to Socket:", error.message);
   }
 }
+async function sendAnalyzerTelemetrySocket(analysisMetadataId, telemetry) {
+  try {
+    const url2 = getSocketApiUrl("tier1-reachability-scan/add-analyzer-telemetry");
+    const data2 = {
+      analysis_metadata_id: analysisMetadataId,
+      telemetry
+    };
+    await axios2.post(url2, data2, { headers: getAuthHeaders() });
+  } catch (error) {
+    console.warn("Failed to send analyzer telemetry to Socket:", error.message);
+  }
+}
 async function registerDiagnosticsToAnalysisMetadataSocket(analysisMetadataId, diagnosticsData) {
   const abnormalExit = diagnosticsData.analysisDiagnostics.aborted ? "ABORTED" : diagnosticsData.analysisDiagnostics.timeout ? "TIMEOUT" : "NONE";
   try {
@@ -80698,6 +80710,7 @@ function getSocketAPI() {
     sendLogChunkSocket,
     createAnalysisMetadataSocket,
     sendTelemetrySocket,
+    sendAnalyzerTelemetrySocket,
     registerDiagnosticsToAnalysisMetadataSocket
   };
 }
@@ -80840,6 +80853,14 @@ var DashboardAPI = class {
       await this.socketAPI.sendTelemetrySocket(analysisMetadataId, telemetry);
     }
   }
+  async sendAnalyzerTelemetry(analysisMetadataId, telemetry) {
+    if (this.disableAnalyticsSharing) {
+      return;
+    }
+    if (this.socketMode) {
+      await this.socketAPI.sendAnalyzerTelemetrySocket(analysisMetadataId, telemetry);
+    }
+  }
   async registerDiagnosticsToAnalysisMetadata(analysisMetadataId, diagnosticsData) {
     if (this.disableAnalyticsSharing || !analysisMetadataId) {
       return;
@@ -80871,7 +80892,7 @@ function createWorkspaceWarning(type) {
 
 // ../utils/src/go-utils.ts
 import { constants, copyFile, cp as cp2, mkdtemp } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // ../utils/src/command-utils.ts
 import assert from "assert";
@@ -80936,6 +80957,71 @@ var TelemetryCollector = class {
   }
 };
 
+// ../utils/src/telemetry/analyzer-telemetry-server.ts
+import { existsSync, readFileSync, watchFile, unwatchFile } from "fs";
+import { unlink, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import { randomBytes } from "crypto";
+var AnalyzerTelemetryServer = class {
+  constructor(handler) {
+    this.handler = handler;
+    const fileId = randomBytes(8).toString("hex");
+    this.filePath = join2(tmpdir(), `analyzer-telemetry-${fileId}.jsonl`);
+  }
+  filePath;
+  lastReadPosition = 0;
+  watching = false;
+  /**
+   * Starts the server and returns the file path that analyzers should write to.
+   */
+  async start() {
+    await writeFile2(this.filePath, "");
+    this.watching = true;
+    watchFile(this.filePath, { interval: 1e3 }, () => {
+      this.processNewEvents();
+    });
+    return this.filePath;
+  }
+  processNewEvents() {
+    if (!existsSync(this.filePath)) return;
+    try {
+      const content = readFileSync(this.filePath, "utf-8");
+      const newContent = content.substring(this.lastReadPosition);
+      this.lastReadPosition = content.length;
+      if (!newContent) return;
+      const lines = newContent.split("\n");
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            const event = JSON.parse(line);
+            this.handler.onAnalyzerEvent(event);
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Closes the server and cleans up the file.
+   */
+  async close() {
+    this.processNewEvents();
+    this.handler.close?.();
+    if (this.watching) {
+      unwatchFile(this.filePath);
+      this.watching = false;
+    }
+    if (existsSync(this.filePath)) {
+      try {
+        await unlink(this.filePath);
+      } catch {
+      }
+    }
+  }
+};
+
 // ../utils/src/command-utils.ts
 var DEFAULT_TIMEOUT_MS = 30 * 60 * 1e3;
 async function execAndLogOnFailure(cmd, dir, options, logLevel = "info") {
@@ -80988,15 +81074,22 @@ function startTelemetry(pid, handler) {
 async function execNeverFail(cmd, dir, options) {
   const stopHeartbeat = options?.heartbeat ? startHeartbeat(options.heartbeat) : void 0;
   let stopTelemetry;
+  let analyzerTelemetryServer;
+  let analyzerTelemetryFilePath;
+  if (options?.analyzerTelemetryHandler) {
+    analyzerTelemetryServer = new AnalyzerTelemetryServer(options.analyzerTelemetryHandler);
+    analyzerTelemetryFilePath = await analyzerTelemetryServer.start();
+  }
   try {
     return await new Promise((resolve23) => {
       let args;
       if (typeof cmd !== "string") [cmd, ...args] = cmd;
       const timeout = options?.timeout ?? DEFAULT_TIMEOUT_MS;
+      const env = analyzerTelemetryFilePath ? { ...options?.env ?? process.env, ANALYZER_TELEMETRY_FILE_PATH: analyzerTelemetryFilePath } : options?.env;
       const childProcess = execFile2(
         cmd,
         args,
-        { ...options, cwd: dir, maxBuffer: 1024 * 1024 * 1024, shell: args === void 0, timeout },
+        { ...options, env, cwd: dir, maxBuffer: 1024 * 1024 * 1024, shell: args === void 0, timeout },
         (error, stdout, stderr) => {
           resolve23({ error, stdout, stderr });
         }
@@ -81022,6 +81115,7 @@ async function execNeverFail(cmd, dir, options) {
   } finally {
     stopHeartbeat?.();
     stopTelemetry?.();
+    await analyzerTelemetryServer?.close();
   }
 }
 async function exec(cmd, dir, options) {
@@ -81129,9 +81223,9 @@ async function runCommandResolveStdOut2(cmd, dir, options) {
 // ../utils/src/file-utils.ts
 var import_lodash3 = __toESM(require_lodash(), 1);
 var import_micromatch = __toESM(require_micromatch(), 1);
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { access, cp, readdir, stat } from "fs/promises";
-import { basename, join as join2, relative, resolve } from "path";
+import { basename, join as join3, relative, resolve } from "path";
 
 // ../web-compat-utils/src/async.ts
 async function asyncMap(array, mapper, concurrency = 1) {
@@ -81193,7 +81287,7 @@ function findParent(dir, predicate, wholePath) {
 async function getFiles(dir, excludeDirs) {
   async function helper(currDir, arrayOfFiles) {
     for (const item of await readdir(currDir, { withFileTypes: true })) {
-      const itemPath = join2(currDir, item.name);
+      const itemPath = join3(currDir, item.name);
       if (item.isDirectory()) {
         if (!excludeDirs?.includes(item.name)) await helper(itemPath, arrayOfFiles);
       } else if (item.isFile()) {
@@ -81202,7 +81296,7 @@ async function getFiles(dir, excludeDirs) {
     }
     return arrayOfFiles;
   }
-  if (!existsSync(dir)) return [];
+  if (!existsSync2(dir)) return [];
   return uniq(await helper(dir, []));
 }
 async function isDirectory(filePath) {
@@ -81236,7 +81330,7 @@ async function runGoModWhy(moduleMode, projectFolder, toCheck) {
 var getIrrelevantModules = runGoModWhy.bind(null, true);
 var getIrrelevantPackages = runGoModWhy.bind(null, false);
 async function getModuleInfo(goModPath) {
-  if (!goModPath.endsWith(".mod")) goModPath = join3(goModPath, "go.mod");
+  if (!goModPath.endsWith(".mod")) goModPath = join4(goModPath, "go.mod");
   const stdout = await runCommandResolveStdOut2(["go", "mod", "edit", "-json", goModPath]);
   return JSON.parse(stdout);
 }
@@ -87648,6 +87742,41 @@ function createTelemetryHandler(dashboardAPI4, analysisMetadataId) {
     intervalMs: 5e3
   };
 }
+function createAnalyzerTelemetryHandler(dashboardAPI4, analysisMetadataId) {
+  if (!analysisMetadataId) {
+    return void 0;
+  }
+  let eventBuffer = [];
+  let flushTimer;
+  const flushEvents = () => {
+    if (eventBuffer.length === 0) return;
+    const eventsToSend = eventBuffer;
+    eventBuffer = [];
+    dashboardAPI4.sendAnalyzerTelemetry(analysisMetadataId, eventsToSend).catch((err) => logger.debug("Failed to send analyzer telemetry:", err));
+  };
+  return {
+    onAnalyzerEvent: (event) => {
+      eventBuffer.push({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        event
+      });
+      if (flushTimer) clearTimeout(flushTimer);
+      if (eventBuffer.length >= 10) {
+        flushEvents();
+      } else {
+        flushTimer = setTimeout(flushEvents, 1e3);
+        flushTimer.unref?.();
+      }
+    },
+    close: () => {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = void 0;
+      }
+      flushEvents();
+    }
+  };
+}
 
 // ../utils/src/promise-queue.ts
 var PromiseQueue = class {
@@ -87768,7 +87897,7 @@ import assert7 from "assert";
 import { resolve as resolve19 } from "path";
 
 // ../utils/src/pip-utils.ts
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
 import { dirname, resolve as resolve3 } from "node:path";
 import util4 from "node:util";
@@ -87779,7 +87908,7 @@ var import_semver = __toESM(require_semver4(), 1);
 import { execFileSync } from "child_process";
 import { constants as constants2 } from "fs";
 import { access as access2, readFile as readFile3 } from "fs/promises";
-import { join as join4, resolve as resolve2 } from "path";
+import { join as join5, resolve as resolve2 } from "path";
 import util3 from "util";
 var { once } = import_lodash4.default;
 var systemPython = once(() => {
@@ -87826,7 +87955,7 @@ var PythonVersionsManager = class _PythonVersionsManager {
     const absPath = resolve2(this.projectDir, workspacePath);
     for (const parent2 of parents(absPath))
       try {
-        return [(await readFile3(join4(parent2, ".python-version"), "utf-8")).split("\n")[0].trim()];
+        return [(await readFile3(join5(parent2, ".python-version"), "utf-8")).split("\n")[0].trim()];
       } catch (e) {
         if (e.code !== "ENOENT") logger.warn("Failed to read python version file with error", e);
       }
@@ -88130,7 +88259,7 @@ async function parseTomlFile(file) {
 }
 async function getPyProjectParsed(dir) {
   const pyprojectLoc = resolve3(dir, "pyproject.toml");
-  if (!existsSync2(pyprojectLoc)) return void 0;
+  if (!existsSync3(pyprojectLoc)) return void 0;
   return parseTomlFile(pyprojectLoc);
 }
 var uvPythonPlatform = "x86_64-manylinux_2_40";
@@ -88185,15 +88314,15 @@ function addPathToTrie(root3, vulnPath) {
 // dist/whole-program-code-aware-vulnerability-scanner/python/python-code-aware-vulnerability-scanner.js
 var import_lodash14 = __toESM(require_lodash(), 1);
 import assert6 from "assert";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { cp as cp7, readdir as readdir4, readFile as readFile11, rm as rm5 } from "fs/promises";
 var import_semver3 = __toESM(require_semver2(), 1);
-import { basename as basename11, dirname as dirname15, join as join16, resolve as resolve17, sep as sep5 } from "path";
+import { basename as basename11, dirname as dirname15, join as join17, resolve as resolve17, sep as sep5 } from "path";
 import util5 from "util";
 
 // ../utils/src/constants.ts
 var import_lodash5 = __toESM(require_lodash(), 1);
-import { dirname as dirname2, join as join5 } from "node:path";
+import { dirname as dirname2, join as join6 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var { once: once2 } = import_lodash5.default;
 var fileName = fileURLToPath3(import.meta.url);
@@ -88206,16 +88335,16 @@ var COANA_ROOT = once2(() => {
   return coanaRoot;
 });
 var REPOS_PATH = once2(() => {
-  return process.env.REPOS_PATH ?? join5(COANA_ROOT(), "repos");
+  return process.env.REPOS_PATH ?? join6(COANA_ROOT(), "repos");
 });
 var COANA_REPOS_PATH = once2(() => {
-  return process.env.COANA_REPOS_PATH ?? join5(REPOS_PATH(), "coana-tech");
+  return process.env.COANA_REPOS_PATH ?? join6(REPOS_PATH(), "coana-tech");
 });
 var REQUIREMENTS_FILES_SEARCH_DEPTH = 2;
 
 // ../utils/src/download-utils.ts
-import { existsSync as existsSync3 } from "fs";
-import { writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { writeFile as writeFile3 } from "fs/promises";
 async function downloadFile(fileUrl, outputFile) {
   try {
     const response = await axios_default.get(fileUrl, {
@@ -88227,8 +88356,8 @@ async function downloadFile(fileUrl, outputFile) {
       }
     });
     if (response.status < 200 || response.status >= 300) return false;
-    await writeFile2(outputFile, Buffer.from(response.data));
-    return existsSync3(outputFile);
+    await writeFile3(outputFile, Buffer.from(response.data));
+    return existsSync4(outputFile);
   } catch {
     return false;
   }
@@ -88237,11 +88366,11 @@ async function downloadFile(fileUrl, outputFile) {
 // ../utils/src/file-tree-utils.ts
 import { closeSync, lstatSync as lstatSync2, openSync, readdirSync as readdirSync3, readSync } from "fs";
 import { readdir as readdir3 } from "fs/promises";
-import { basename as basename3, join as join7, relative as relative3, resolve as resolve5 } from "path";
+import { basename as basename3, join as join8, relative as relative3, resolve as resolve5 } from "path";
 
 // ../utils/src/package-utils.ts
-import { parse as parse2, join as join6, resolve as resolve4, normalize as normalize2, dirname as dirname3, basename as basename2, relative as relative2 } from "path";
-import { existsSync as existsSync4, readFileSync, readdirSync as readdirSync2, statSync, writeFileSync } from "fs";
+import { parse as parse2, join as join7, resolve as resolve4, normalize as normalize2, dirname as dirname3, basename as basename2, relative as relative2 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync, writeFileSync } from "fs";
 function getPackageJsonObject(workspaceRoot) {
   const packageJSONContent = getPackageJsonContent(workspaceRoot);
   if (!packageJSONContent) return void 0;
@@ -88249,11 +88378,11 @@ function getPackageJsonObject(workspaceRoot) {
 }
 function getPackageJsonContent(workspaceRoot) {
   const packageJsonPath = getPackageJSONPath(workspaceRoot);
-  if (existsSync4(packageJsonPath)) return readFileSync(packageJsonPath, "utf8");
+  if (existsSync5(packageJsonPath)) return readFileSync2(packageJsonPath, "utf8");
   return void 0;
 }
 function getPackageJSONPath(workspaceRoot) {
-  return join6(workspaceRoot, "package.json");
+  return join7(workspaceRoot, "package.json");
 }
 
 // ../utils/src/file-tree-utils.ts
@@ -88267,7 +88396,7 @@ async function findFilesInPythonProjectMatching(projectDir, fileMatcher, maxDept
     ) || requirementsFilesDepth <= 0 && filesAndDirectories.some(({ name: name2 }) => /requirements.*\.txt/.test(name2)))
       return;
     for (const fileOrDirectory of filesAndDirectories) {
-      const fullPath = join7(path10, fileOrDirectory.name);
+      const fullPath = join8(path10, fileOrDirectory.name);
       if (fileOrDirectory.isDirectory()) {
         if (shouldIgnoreDir(fileOrDirectory.name, projectDir === path10)) continue;
         directoriesToTraverse.push(fileOrDirectory.name);
@@ -88277,7 +88406,7 @@ async function findFilesInPythonProjectMatching(projectDir, fileMatcher, maxDept
     }
     if (depthLeft === 0) return;
     for (const dir of directoriesToTraverse) {
-      await recHelper(join7(path10, dir), depthLeft - 1, requirementsFilesDepth - 1);
+      await recHelper(join8(path10, dir), depthLeft - 1, requirementsFilesDepth - 1);
     }
   };
   await recHelper(projectDir, maxDepth, maxRequirementsFileDepth);
@@ -88289,11 +88418,11 @@ async function findFilesInPythonProjectMatching(projectDir, fileMatcher, maxDept
 
 // ../utils/src/tmp-file.ts
 import { rm, mkdtemp as mkdtemp2, cp as cp3, lstat as lstat2 } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join8, relative as relative4, sep as sep2, extname } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join9, relative as relative4, sep as sep2, extname } from "path";
 async function createTmpDirectory(prefix) {
   try {
-    const tmpDir = await mkdtemp2(join8(tmpdir(), prefix));
+    const tmpDir = await mkdtemp2(join9(tmpdir2(), prefix));
     return tmpDir;
   } catch (err) {
     console.log("Error creating tmp directory", err);
@@ -88532,12 +88661,12 @@ var ToolPathResolver = class {
 
 // dist/whole-program-code-aware-vulnerability-scanner/code-aware-vulnerability-scanner.js
 var import_lodash13 = __toESM(require_lodash(), 1);
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { resolve as resolve16 } from "path";
 
 // dist/whole-program-code-aware-vulnerability-scanner/dotnet/dotnet-code-aware-vulnerability-scanner.js
 var import_lodash6 = __toESM(require_lodash(), 1);
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { basename as basename7, dirname as dirname10, extname as extname3, resolve as resolve9 } from "node:path";
 
 // ../utils/src/nuget-utils.ts
@@ -88549,10 +88678,10 @@ function getUrlForPackage(packageName, version3) {
 
 // ../utils/src/tool-extractor.ts
 import { createHash } from "node:crypto";
-import { createReadStream, createWriteStream as createWriteStream2, readFileSync as readFileSync2, statSync as statSync3 } from "node:fs";
-import { copyFile as copyFile2, cp as cp4, mkdir as mkdir4, writeFile as writeFile3 } from "node:fs/promises";
-import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename5, dirname as dirname8, join as join10 } from "node:path";
+import { createReadStream, createWriteStream as createWriteStream2, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
+import { copyFile as copyFile2, cp as cp4, mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import { basename as basename5, dirname as dirname8, join as join11 } from "node:path";
 import { pipeline } from "node:stream/promises";
 import { createGunzip } from "node:zlib";
 
@@ -92051,7 +92180,7 @@ import fs9 from "node:fs";
 
 // ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/unpack.js
 import assert3 from "node:assert";
-import { randomBytes } from "node:crypto";
+import { randomBytes as randomBytes2 } from "node:crypto";
 import fs8 from "node:fs";
 import path7 from "node:path";
 
@@ -92424,7 +92553,7 @@ var mkdir3 = (dir, opt, cb) => {
   const gid = opt.gid;
   const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid);
   const preserve = opt.preserve;
-  const unlink = opt.unlink;
+  const unlink2 = opt.unlink;
   const cache = opt.cache;
   const cwd = normalizeWindowsPath(opt.cwd);
   const done = (er, created) => {
@@ -92456,33 +92585,33 @@ var mkdir3 = (dir, opt, cb) => {
   }
   const sub = normalizeWindowsPath(path6.relative(cwd, dir));
   const parts = sub.split("/");
-  mkdir_(cwd, parts, mode, cache, unlink, cwd, void 0, done);
+  mkdir_(cwd, parts, mode, cache, unlink2, cwd, void 0, done);
 };
-var mkdir_ = (base, parts, mode, cache, unlink, cwd, created, cb) => {
+var mkdir_ = (base, parts, mode, cache, unlink2, cwd, created, cb) => {
   if (!parts.length) {
     return cb(null, created);
   }
   const p = parts.shift();
   const part = normalizeWindowsPath(path6.resolve(base + "/" + p));
   if (cGet(cache, part)) {
-    return mkdir_(part, parts, mode, cache, unlink, cwd, created, cb);
+    return mkdir_(part, parts, mode, cache, unlink2, cwd, created, cb);
   }
-  fs7.mkdir(part, mode, onmkdir(part, parts, mode, cache, unlink, cwd, created, cb));
+  fs7.mkdir(part, mode, onmkdir(part, parts, mode, cache, unlink2, cwd, created, cb));
 };
-var onmkdir = (part, parts, mode, cache, unlink, cwd, created, cb) => (er) => {
+var onmkdir = (part, parts, mode, cache, unlink2, cwd, created, cb) => (er) => {
   if (er) {
     fs7.lstat(part, (statEr, st) => {
       if (statEr) {
         statEr.path = statEr.path && normalizeWindowsPath(statEr.path);
         cb(statEr);
       } else if (st.isDirectory()) {
-        mkdir_(part, parts, mode, cache, unlink, cwd, created, cb);
-      } else if (unlink) {
+        mkdir_(part, parts, mode, cache, unlink2, cwd, created, cb);
+      } else if (unlink2) {
         fs7.unlink(part, (er2) => {
           if (er2) {
             return cb(er2);
           }
-          fs7.mkdir(part, mode, onmkdir(part, parts, mode, cache, unlink, cwd, created, cb));
+          fs7.mkdir(part, mode, onmkdir(part, parts, mode, cache, unlink2, cwd, created, cb));
         });
       } else if (st.isSymbolicLink()) {
         return cb(new SymlinkError(part, part + "/" + parts.join("/")));
@@ -92492,7 +92621,7 @@ var onmkdir = (part, parts, mode, cache, unlink, cwd, created, cb) => (er) => {
     });
   } else {
     created = created || part;
-    mkdir_(part, parts, mode, cache, unlink, cwd, created, cb);
+    mkdir_(part, parts, mode, cache, unlink2, cwd, created, cb);
   }
 };
 var checkCwdSync = (dir) => {
@@ -92517,7 +92646,7 @@ var mkdirSync3 = (dir, opt) => {
   const gid = opt.gid;
   const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid);
   const preserve = opt.preserve;
-  const unlink = opt.unlink;
+  const unlink2 = opt.unlink;
   const cache = opt.cache;
   const cwd = normalizeWindowsPath(opt.cwd);
   const done = (created2) => {
@@ -92556,7 +92685,7 @@ var mkdirSync3 = (dir, opt) => {
       if (st.isDirectory()) {
         cSet(cache, part, true);
         continue;
-      } else if (unlink) {
+      } else if (unlink2) {
         fs7.unlinkSync(part);
         fs7.mkdirSync(part, mode);
         created = created || part;
@@ -92581,14 +92710,14 @@ var normalizeUnicode = (s2) => {
 };
 
 // ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/path-reservations.js
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 var platform5 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
 var isWindows2 = platform5 === "win32";
 var getDirs = (path10) => {
   const dirs = path10.split("/").slice(0, -1).reduce((set, path11) => {
     const s2 = set[set.length - 1];
     if (s2 !== void 0) {
-      path11 = join9(s2, path11);
+      path11 = join10(s2, path11);
     }
     set.push(path11 || "/");
     return set;
@@ -92606,7 +92735,7 @@ var PathReservations = class {
   #running = /* @__PURE__ */ new Set();
   reserve(paths, fn) {
     paths = isWindows2 ? ["win32 parallelization disabled"] : paths.map((p) => {
-      return stripTrailingSlashes(join9(normalizeUnicode(p))).toLowerCase();
+      return stripTrailingSlashes(join10(normalizeUnicode(p))).toLowerCase();
     });
     const dirs = new Set(paths.map((path10) => getDirs(path10)).reduce((a2, b) => a2.concat(b)));
     this.#reservations.set(fn, { dirs, paths });
@@ -92746,7 +92875,7 @@ var unlinkFile = (path10, cb) => {
   if (!isWindows3) {
     return fs8.unlink(path10, cb);
   }
-  const name2 = path10 + ".DELETE." + randomBytes(16).toString("hex");
+  const name2 = path10 + ".DELETE." + randomBytes2(16).toString("hex");
   fs8.rename(path10, name2, (er) => {
     if (er) {
       return cb(er);
@@ -92758,7 +92887,7 @@ var unlinkFileSync = (path10) => {
   if (!isWindows3) {
     return fs8.unlinkSync(path10);
   }
-  const name2 = path10 + ".DELETE." + randomBytes(16).toString("hex");
+  const name2 = path10 + ".DELETE." + randomBytes2(16).toString("hex");
   fs8.renameSync(path10, name2);
   fs8.unlinkSync(name2);
 };
@@ -93690,13 +93819,13 @@ async function getNodeExecutable(overridePath) {
     const nodeArch = arch === "arm" ? "arm64" : arch;
     const isWindows4 = platform7 === "win32";
     const binaryName = isWindows4 ? `node-${platform7}-${nodeArch}.exe.gz` : `node-${platform7}-${nodeArch}.gz`;
-    const compressedBinaryPath = join10(extractedPath, binaryName);
+    const compressedBinaryPath = join11(extractedPath, binaryName);
     if (!await exists(compressedBinaryPath)) {
       throw new Error(`Node.js binary not found: ${compressedBinaryPath}. Platform: ${platform7}-${nodeArch}`);
     }
-    const tmpDir = join10(getExtractionBaseDir(), "node-runtime");
+    const tmpDir = join11(getExtractionBaseDir(), "node-runtime");
     await mkdir4(tmpDir, { recursive: true });
-    const nodeBinaryPath = join10(tmpDir, isWindows4 ? "node.exe" : "node");
+    const nodeBinaryPath = join11(tmpDir, isWindows4 ? "node.exe" : "node");
     logger.debug(`Decompressing Node.js binary to ${nodeBinaryPath}...`);
     await pipeline(
       createReadStream(compressedBinaryPath),
@@ -93712,8 +93841,8 @@ var cliVersion;
 function getCliVersion() {
   if (cliVersion) return cliVersion;
   try {
-    const packageJsonPath = isNexeMode() ? join10(NEXE_VIRTUAL_FS_ROOT, "package.json") : join10(dirname8(dirname8(dirname8(dirname8(__filename)))), "npm-package-cli", "package.json");
-    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    const packageJsonPath = isNexeMode() ? join11(NEXE_VIRTUAL_FS_ROOT, "package.json") : join11(dirname8(dirname8(dirname8(dirname8(__filename)))), "npm-package-cli", "package.json");
+    const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
     if (process.env.ALWAYS_REEXTRACT_TOOLS === "true") {
       logger.info("ALWAYS_REEXTRACT_TOOLS is set to true, re-extracting tools");
       const randomVersion = Math.random().toString().slice(2, 8);
@@ -93729,7 +93858,7 @@ function getCliVersion() {
 }
 function getExtractionBaseDir() {
   const version3 = getCliVersion();
-  return join10(tmpdir2(), `coana-cli-v${version3}`);
+  return join11(tmpdir3(), `coana-cli-v${version3}`);
 }
 async function calculateChecksum(filePath) {
   const hash = createHash("sha256");
@@ -93741,8 +93870,8 @@ function loadChecksums() {
     if (!isNexeMode()) {
       throw new Error("Tool extraction is only supported in nexe mode");
     }
-    const checksumsPath = join10(NEXE_VIRTUAL_FS_ROOT, "checksums.json");
-    return JSON.parse(readFileSync2(checksumsPath, "utf-8"));
+    const checksumsPath = join11(NEXE_VIRTUAL_FS_ROOT, "checksums.json");
+    return JSON.parse(readFileSync3(checksumsPath, "utf-8"));
   } catch (error) {
     logger.warn("Failed to load checksums.json:", error);
     throw new Error(
@@ -93753,7 +93882,7 @@ function loadChecksums() {
 async function verifyToolIntegrity(toolName, extractedPath, checksums) {
   try {
     for (const [relPath, expectedChecksum] of Object.entries(checksums)) {
-      const filePath = join10(extractedPath, relPath);
+      const filePath = join11(extractedPath, relPath);
       if (!await exists(filePath)) {
         logger.debug(`File ${filePath} does not exist`);
         return false;
@@ -93786,8 +93915,8 @@ async function extractTool(toolName, resourcePath) {
       return cached.extractedPath;
     }
     const baseDir = getExtractionBaseDir();
-    const extractedPath = join10(baseDir, resourcePath);
-    const markerFile = join10(extractedPath, ".extracted");
+    const extractedPath = join11(baseDir, resourcePath);
+    const markerFile = join11(extractedPath, ".extracted");
     if (await exists(markerFile)) {
       const checksums = loadChecksums();
       const toolChecksums = checksums[toolName];
@@ -93802,7 +93931,7 @@ async function extractTool(toolName, resourcePath) {
     logger.debug(`Extracting ${toolName} to ${extractedPath}...`);
     try {
       await mkdir4(extractedPath, { recursive: true });
-      const sourcePath = isNexeMode() ? join10(NEXE_VIRTUAL_FS_ROOT, resourcePath) : resourcePath;
+      const sourcePath = isNexeMode() ? join11(NEXE_VIRTUAL_FS_ROOT, resourcePath) : resourcePath;
       if (!await exists(sourcePath)) {
         throw new Error(
           `Tool source not found: ${sourcePath}. isNexeMode=${isNexeMode()}, NEXE_VIRTUAL_FS_ROOT=${NEXE_VIRTUAL_FS_ROOT}`
@@ -93813,12 +93942,12 @@ async function extractTool(toolName, resourcePath) {
         await cp4(sourcePath, extractedPath, { recursive: true });
       } else if (stats.isFile()) {
         const fileName2 = basename5(sourcePath);
-        const destFile = join10(extractedPath, fileName2);
+        const destFile = join11(extractedPath, fileName2);
         await copyFile2(sourcePath, destFile);
       } else {
         throw new Error(`Tool source is neither a file nor a directory: ${sourcePath}`);
       }
-      await writeFile3(markerFile, (/* @__PURE__ */ new Date()).toISOString());
+      await writeFile4(markerFile, (/* @__PURE__ */ new Date()).toISOString());
       logger.debug(`Successfully extracted ${toolName}`);
       extractedTools.set(toolName, { extractedPath });
       return extractedPath;
@@ -93858,7 +93987,7 @@ var CocoaHeuristics = {
 
 // dist/whole-program-code-aware-vulnerability-scanner/dotnet/dotnet-code-aware-vulnerability-scanner.js
 var import_adm_zip = __toESM(require_adm_zip(), 1);
-import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
 import { randomUUID } from "node:crypto";
 
 // dist/whole-program-code-aware-vulnerability-scanner/dotnet/constants.js
@@ -93877,7 +94006,7 @@ function getClassGraphAnalysisCliPath() {
 // ../utils/src/nuget-project-utils.ts
 var import_parse_xml2 = __toESM(require_dist(), 1);
 import { readFile as readFile5 } from "node:fs/promises";
-import { dirname as dirname9, join as join11, relative as relative5, resolve as resolve8, basename as basename6, extname as extname2 } from "node:path";
+import { dirname as dirname9, join as join12, relative as relative5, resolve as resolve8, basename as basename6, extname as extname2 } from "node:path";
 
 // ../utils/src/xml-utils.ts
 var import_parse_xml = __toESM(require_dist(), 1);
@@ -93983,7 +94112,7 @@ function createAttributeMap(xmlElement, xmlContent) {
 }
 
 // ../utils/src/nuget-project-utils.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 
 // ../utils/dist/version-comparison/version-satisfies.js
 var import_semver2 = __toESM(require_semver4(), 1);
@@ -95414,7 +95543,7 @@ var ecosystemMap = {
   RUST: {
     sortVersions: import_semver2.sort,
     isPrerelease: semverIsPrerelease,
-    versionSatisfiesSpecifier: (version3, specifier) => semverSatisfiesSpecifier(version3, /^\d/.test(specifier) ? `^${specifier}` : specifier),
+    versionSatisfiesSpecifier: (version3, specifier) => specifier.split(",").map((part) => part.trim()).every((trimmed) => semverSatisfiesSpecifier(version3, /^\d/.test(trimmed) ? `^${trimmed}` : trimmed)),
     versionSatisfiesRelation: import_semver2.cmp,
     versionSatisfiesRange: semverSatisfiesRange
   },
@@ -95533,7 +95662,7 @@ async function loadNuGetProject(rootDir, projectFile, validateFile) {
 }
 async function loadNuGetProjectOrTarget(rootDir, projectFile, mainProject, visited, validateFile) {
   const validatedProjectPath = validateFile ? validateFile(resolve8(rootDir, projectFile)) : resolve8(rootDir, projectFile);
-  if (!validatedProjectPath || !existsSync5(validatedProjectPath)) return void 0;
+  if (!validatedProjectPath || !existsSync6(validatedProjectPath)) return void 0;
   if (visited.has(validatedProjectPath)) return void 0;
   visited.set(validatedProjectPath);
   const sourceText = await readFile5(validatedProjectPath, "utf-8");
@@ -95610,7 +95739,7 @@ async function findDirectoryBuildPropsProjects(currentProject, mainProject, visi
   const projectsReverse = [];
   let currentDir = dirname9(currentProject.validatedProjectPath);
   while (currentDir.startsWith(currentProject.rootDir) && currentDir !== dirname9(currentDir)) {
-    const unvalidatedPath = join11(currentDir, "Directory.Build.props");
+    const unvalidatedPath = join12(currentDir, "Directory.Build.props");
     const validatedPath = validateFile ? validateFile(unvalidatedPath) : unvalidatedPath;
     if (validatedPath && validatedPath !== currentProject.validatedProjectPath) {
       const directoryBuildPropsProject = await loadNuGetProjectOrTarget(
@@ -95631,7 +95760,7 @@ async function findDirectoryBuildPropsProjects(currentProject, mainProject, visi
 async function findDirectoryPackagesPropsProject(currentProject, mainProject, visited, validateFile) {
   let currentDir = dirname9(currentProject.validatedProjectPath);
   while (currentDir.startsWith(currentProject.rootDir) && currentDir !== dirname9(currentDir)) {
-    const unvalidatedPath = join11(currentDir, "Directory.Packages.props");
+    const unvalidatedPath = join12(currentDir, "Directory.Packages.props");
     const validatedPath = validateFile ? validateFile(unvalidatedPath) : unvalidatedPath;
     if (validatedPath) {
       return validatedPath !== currentProject.validatedProjectPath ? await loadNuGetProjectOrTarget(currentProject.rootDir, unvalidatedPath, mainProject, visited, validateFile) : void 0;
@@ -95698,7 +95827,7 @@ async function handleImportElement(currentProject, importElement, mainProject, v
   if (!importPath) return;
   const resolvedPath = resolve8(dirname9(currentProject.validatedProjectPath), normalizeMSBuildPath(importPath));
   const validatedPath = validateFile ? validateFile(resolvedPath) : resolvedPath;
-  if (!validatedPath || !existsSync5(validatedPath)) return;
+  if (!validatedPath || !existsSync6(validatedPath)) return;
   const importedProject = await loadNuGetProjectOrTarget(
     currentProject.rootDir,
     resolvedPath,
@@ -96037,7 +96166,7 @@ var DotnetCodeAwareVulnerabilityScanner = class _DotnetCodeAwareVulnerabilitySca
       };
       const inputFile = resolve9(tmpDir, "input.json");
       const outputFile = resolve9(tmpDir, "output.json");
-      await writeFile4(inputFile, JSON.stringify(options));
+      await writeFile5(inputFile, JSON.stringify(options));
       const timeoutMs = Math.max(timeoutInSeconds * 1.5, timeoutInSeconds + 30) * 1e3;
       const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runDotnetDirectDependencyAnalysis -i ${inputFile} -o ${outputFile} --cocoa ${getCocoaPath()} --tree-sitter-c-sharp ${getTreeSitterCSharpPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.dotnet });
       if (result.error)
@@ -96046,7 +96175,7 @@ var DotnetCodeAwareVulnerabilityScanner = class _DotnetCodeAwareVulnerabilitySca
       return packageIds?.map((packageId) => this.depIdToPurl.get(packageId)).filter((purl) => purl !== void 0).map((purl) => purl.name ?? "");
     });
   }
-  async runAnalysis(vulnerabilities, heuristic, timeoutInSeconds, _experiment, telemetryHandler) {
+  async runAnalysis(vulnerabilities, heuristic, timeoutInSeconds, _experiment, telemetryHandler, analyzerTelemetryHandler) {
     try {
       this.statusUpdater?.("Preparing code for analysis...");
       const packagesToAnalyze = heuristic.getPackagesToAnalyze(vulnerabilities);
@@ -96055,12 +96184,12 @@ var DotnetCodeAwareVulnerabilityScanner = class _DotnetCodeAwareVulnerabilitySca
         const purl = this.depIdToPurl.get(packageId);
         return purl?.name && packagesToAnalyzeSet.has(purl.name);
       }));
-      return await this.actuallyRunAnalysis(vulnerabilities.flatMap((v) => v.vulnerabilityAccessPaths), timeoutInSeconds, filteredDeps, telemetryHandler);
+      return await this.actuallyRunAnalysis(vulnerabilities.flatMap((v) => v.vulnerabilityAccessPaths), timeoutInSeconds, filteredDeps, telemetryHandler, analyzerTelemetryHandler);
     } catch (e) {
       return { type: "error", message: e.message };
     }
   }
-  async actuallyRunAnalysis(vulnerabilityAccessPaths, timeoutInSeconds, filteredDeps, telemetryHandler) {
+  async actuallyRunAnalysis(vulnerabilityAccessPaths, timeoutInSeconds, filteredDeps, telemetryHandler, analyzerTelemetryHandler) {
     this.statusUpdater?.("Running analysis...");
     return withTmpDirectory("dotnet-run-analysis", async (tmpDir) => {
       try {
@@ -96076,9 +96205,9 @@ var DotnetCodeAwareVulnerabilityScanner = class _DotnetCodeAwareVulnerabilitySca
       };
       const inputFile = resolve9(tmpDir, "input.json");
       const outputFile = resolve9(tmpDir, "output.json");
-      await writeFile4(inputFile, JSON.stringify(options));
+      await writeFile5(inputFile, JSON.stringify(options));
       const timeoutMs = Math.max(timeoutInSeconds * 1.5, timeoutInSeconds + 30) * 1e3;
-      const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runDotnetReachabilityAnalysis -i ${inputFile} -o ${outputFile} --cocoa ${getCocoaPath()} --tree-sitter-c-sharp ${getTreeSitterCSharpPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.dotnet, telemetryHandler });
+      const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runDotnetReachabilityAnalysis -i ${inputFile} -o ${outputFile} --cocoa ${getCocoaPath()} --tree-sitter-c-sharp ${getTreeSitterCSharpPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.dotnet, telemetryHandler, analyzerTelemetryHandler });
       if (result.error)
         return { type: "error", message: result.error.message ?? "unknown error" };
       const { success, error, analysisDiagnostics: diagnostics, vulnerablePaths, reachablePackageIds } = JSON.parse(await readFile6(outputFile, "utf-8")).result;
@@ -96126,12 +96255,12 @@ var DotnetCodeAwareVulnerabilityScanner = class _DotnetCodeAwareVulnerabilitySca
     };
   }
   getPackagesExcludedUnrelatedToHeuristic() {
-    return Object.entries(this.deps).filter(([_, { src, bin }]) => !src?.length && (!bin || bin.some((f2) => !existsSync6(f2)))).map(([packageId]) => this.depIdToPurl.get(packageId)?.name).filter((name2) => name2 !== void 0).map((name2) => name2);
+    return Object.entries(this.deps).filter(([_, { src, bin }]) => !src?.length && (!bin || bin.some((f2) => !existsSync7(f2)))).map(([packageId]) => this.depIdToPurl.get(packageId)?.name).filter((name2) => name2 !== void 0).map((name2) => name2);
   }
 };
 async function extractNugetPackage(nupkgFilePath, packageName, version3, tmpDir) {
   const packageDir = resolve9(tmpDir, packageName.toLowerCase(), version3.toLowerCase());
-  if (existsSync6(packageDir)) {
+  if (existsSync7(packageDir)) {
     const dllMatcher = (0, import_picomatch.default)("**/*.dll");
     try {
       const allFiles = await getFiles(packageDir);
@@ -96153,7 +96282,7 @@ async function extractNugetPackage(nupkgFilePath, packageName, version3, tmpDir)
         return;
       const entryPath = resolve9(packageDir, entry.entryName);
       await mkdir5(dirname10(entryPath), { recursive: true });
-      await writeFile4(entryPath, entry.getData());
+      await writeFile5(entryPath, entry.getData());
       if (extname3(entryPath) === ".dll") {
         files.push(entryPath);
       }
@@ -96165,7 +96294,7 @@ async function extractNugetPackage(nupkgFilePath, packageName, version3, tmpDir)
 }
 async function downloadAndExtractNugetPackage(packageName, version3, tmpDir) {
   const packageFile = resolve9(tmpDir, `${packageName.toLowerCase()}.${version3.toLowerCase()}.nupkg`);
-  if (!existsSync6(packageFile)) {
+  if (!existsSync7(packageFile)) {
     const packageUrl = getUrlForPackage(packageName, version3);
     const success = await downloadFile(packageUrl, packageFile);
     if (!success) {
@@ -96194,7 +96323,7 @@ function getNuGetLocalRepositoryPaths() {
     // macOS/Linux NuGet cache
     resolve9(home, ".local", "share", "NuGet", "v3-cache")
   ];
-  return repositories.filter((repo) => existsSync6(repo));
+  return repositories.filter((repo) => existsSync7(repo));
 }
 async function findNuGetPackageInLocalRepo(repo, packageName, version3, tmpDir) {
   const dllMatcher = (0, import_picomatch.default)("**/*.dll");
@@ -96230,8 +96359,8 @@ async function convertSocketArtifacts(artifacts, tmpDir) {
 // dist/whole-program-code-aware-vulnerability-scanner/java/java-code-aware-vulnerability-scanner.js
 var import_lodash8 = __toESM(require_lodash(), 1);
 var import_adm_zip2 = __toESM(require_adm_zip(), 1);
-import { existsSync as existsSync8 } from "node:fs";
-import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
+import { existsSync as existsSync9 } from "node:fs";
+import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
 import { basename as basename8, dirname as dirname11, resolve as resolve10 } from "node:path";
 
 // ../../node_modules/.pnpm/cheerio@1.0.0-rc.12/node_modules/cheerio/lib/esm/options.js
@@ -109733,8 +109862,8 @@ var { root: root2 } = static_exports;
 
 // ../utils/src/maven-utils.ts
 var import_lodash7 = __toESM(require_lodash(), 1);
-import { existsSync as existsSync7, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { join as join13 } from "path";
 var { memoize } = import_lodash7.default;
 var memoizedParseShellArgs = memoize(parseShellArgs);
 async function getMavenCLIOpts() {
@@ -109804,13 +109933,13 @@ function getUrlForArtifact(repository, groupId, artifactId, type, classifier, ve
   ).href;
 }
 function getPathToProject(repository, groupId, artifactId) {
-  return join12(repository, groupId.replaceAll(".", "/"), artifactId);
+  return join13(repository, groupId.replaceAll(".", "/"), artifactId);
 }
 function getPathToPackage(repository, groupId, artifactId, version3) {
-  return join12(getPathToProject(repository, groupId, artifactId), version3);
+  return join13(getPathToProject(repository, groupId, artifactId), version3);
 }
 function getPathToArtifact(repository, groupId, artifactId, type, classifier, version3) {
-  return join12(
+  return join13(
     repository,
     groupId.replaceAll(".", "/"),
     artifactId,
@@ -110013,7 +110142,7 @@ var JavaCodeAwareVulnerabilityScanner = class _JavaCodeAwareVulnerabilityScanner
       };
       const inputFile = resolve10(tmpDir, "input.json");
       const outputFile = resolve10(tmpDir, "output.json");
-      await writeFile5(inputFile, JSON.stringify(options));
+      await writeFile6(inputFile, JSON.stringify(options));
       const timeoutMs = Math.max(timeoutInSeconds * 1.5, timeoutInSeconds + 30) * 1e3;
       const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runJvmDirectDependencyAnalysis -i ${inputFile} -o ${outputFile} --javap-service ${getJavapServicePath()} --tree-sitter-java ${getTreeSitterJavaPath()} --tree-sitter-kotlin ${getTreeSitterKotlinPath()} --tree-sitter-scala ${getTreeSitterScalaPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.java });
       if (result.error)
@@ -110022,7 +110151,7 @@ var JavaCodeAwareVulnerabilityScanner = class _JavaCodeAwareVulnerabilityScanner
       return packageIds?.map((packageId) => this.depIdToPurl.get(packageId)).filter((purl) => purl !== void 0).map((purl) => `${purl.namespace}:${purl.name}}`);
     });
   }
-  async runAnalysis(vulnerabilities, heuristic, timeoutInSeconds, _experiment, telemetryHandler) {
+  async runAnalysis(vulnerabilities, heuristic, timeoutInSeconds, _experiment, telemetryHandler, analyzerTelemetryHandler) {
     try {
       this.statusUpdater?.("Preparing code for analysis...");
       const packagesToAnalyze = heuristic.getPackagesToAnalyze(vulnerabilities);
@@ -110031,12 +110160,12 @@ var JavaCodeAwareVulnerabilityScanner = class _JavaCodeAwareVulnerabilityScanner
         const purl = this.depIdToPurl.get(packageId);
         return purl && packagesToAnalyzeSet.has(`${purl.namespace}:${purl.name}}`);
       }));
-      return await this.actuallyRunAnalysis(vulnerabilities.flatMap((v) => v.vulnerabilityAccessPaths), timeoutInSeconds, filteredDeps, telemetryHandler);
+      return await this.actuallyRunAnalysis(vulnerabilities.flatMap((v) => v.vulnerabilityAccessPaths), timeoutInSeconds, filteredDeps, telemetryHandler, analyzerTelemetryHandler);
     } catch (e) {
       return { type: "error", message: e.message };
     }
   }
-  async actuallyRunAnalysis(vulnerabilityAccessPaths, timeoutInSeconds, filteredDeps, telemetryHandler) {
+  async actuallyRunAnalysis(vulnerabilityAccessPaths, timeoutInSeconds, filteredDeps, telemetryHandler, analyzerTelemetryHandler) {
     this.statusUpdater?.("Running analysis...");
     return withTmpDirectory("java-run-analysis", async (tmpDir) => {
       try {
@@ -110052,9 +110181,9 @@ var JavaCodeAwareVulnerabilityScanner = class _JavaCodeAwareVulnerabilityScanner
       };
       const inputFile = resolve10(tmpDir, "input.json");
       const outputFile = resolve10(tmpDir, "output.json");
-      await writeFile5(inputFile, JSON.stringify(options));
+      await writeFile6(inputFile, JSON.stringify(options));
       const timeoutMs = Math.max(timeoutInSeconds * 1.5, timeoutInSeconds + 30) * 1e3;
-      const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runJvmReachabilityAnalysis -i ${inputFile} -o ${outputFile} --javap-service ${getJavapServicePath()} --tree-sitter-java ${getTreeSitterJavaPath()} --tree-sitter-kotlin ${getTreeSitterKotlinPath()} --tree-sitter-scala ${getTreeSitterScalaPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.java, telemetryHandler });
+      const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runJvmReachabilityAnalysis -i ${inputFile} -o ${outputFile} --javap-service ${getJavapServicePath()} --tree-sitter-java ${getTreeSitterJavaPath()} --tree-sitter-kotlin ${getTreeSitterKotlinPath()} --tree-sitter-scala ${getTreeSitterScalaPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.java, telemetryHandler, analyzerTelemetryHandler });
       if (result.error)
         return { type: "error", message: result.error.message ?? "unknown error" };
       const { success, error, analysisDiagnostics: diagnostics, vulnerablePaths, reachablePackageIds } = JSON.parse(await readFile7(outputFile, "utf-8")).result;
@@ -110102,7 +110231,7 @@ var JavaCodeAwareVulnerabilityScanner = class _JavaCodeAwareVulnerabilityScanner
     };
   }
   getPackagesExcludedUnrelatedToHeuristic() {
-    return Object.entries(this.deps).filter(([_, { src, bin }]) => !src?.length && (!bin || bin.some((f2) => !existsSync8(f2)))).map(([packageId]) => this.depIdToPurl.get(packageId)).filter((purl) => purl !== void 0).map((purl) => `${purl.namespace}:${purl.name}}`);
+    return Object.entries(this.deps).filter(([_, { src, bin }]) => !src?.length && (!bin || bin.some((f2) => !existsSync9(f2)))).map(([packageId]) => this.depIdToPurl.get(packageId)).filter((purl) => purl !== void 0).map((purl) => `${purl.namespace}:${purl.name}}`);
   }
 };
 async function convertDependencyChain2(dependencyChain, tmpDir) {
@@ -110146,14 +110275,14 @@ function getLocalRepositoryPaths() {
 async function convertSocketArtifacts2(rootDir, artifacts, tmpDir) {
   const pomMatcher = (0, import_picomatch2.default)("{*-*.,}pom{.xml,}");
   const mavenInstalled = await isMavenInstalled();
-  const localRepositories = getLocalRepositoryPaths().filter((repo) => existsSync8(repo.path));
+  const localRepositories = getLocalRepositoryPaths().filter((repo) => existsSync9(repo.path));
   const mavenLocalRepo = await findLocalRepository() ?? resolve10(process.env.HOME ?? "~", ".m2", "repository");
   async function resolveArtifact(groupId, artifactId, type, classifier, version3, pomFile) {
     for (const repo of localRepositories) {
       switch (repo.type) {
         case "maven": {
           const artifactPath = getPathToArtifact(repo.path, groupId, artifactId, type, classifier, version3);
-          if (existsSync8(artifactPath))
+          if (existsSync9(artifactPath))
             return artifactPath;
           break;
         }
@@ -110176,7 +110305,7 @@ async function convertSocketArtifacts2(rootDir, artifacts, tmpDir) {
         const dependencyGetCmd = cmdt`mvn -f=${basename8(resolve10(rootDir, pomFile))} dependency:get -DgroupId=${groupId} -DartifactId=${artifactId} -Dpackaging=${type} -Dclassifier${classifier} -Dversion=${version3} -Dtransitive=false`;
         await execNeverFail2(dependencyGetCmd, dirname11(resolve10(rootDir, pomFile)));
         const mavenArtifact = getPathToArtifact(mavenLocalRepo, groupId, artifactId, type, classifier, version3);
-        if (existsSync8(mavenArtifact))
+        if (existsSync9(mavenArtifact))
           return mavenArtifact;
       } catch {
       }
@@ -110228,19 +110357,19 @@ async function extractArchivesIfNeeded(tmpDir, apps, deps) {
 
 // dist/whole-program-code-aware-vulnerability-scanner/js/js-code-aware-vulnerability-scanner.js
 import { mkdtempSync } from "fs";
-import { cp as cp5, mkdir as mkdir8, rm as rm3, writeFile as writeFile7 } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
-import { join as join14 } from "path";
+import { cp as cp5, mkdir as mkdir8, rm as rm3, writeFile as writeFile8 } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join15 } from "path";
 
 // dist/whole-program-code-aware-vulnerability-scanner/js/dependency-preparation.js
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { resolve as resolve12 } from "path";
 
 // dist/whole-program-code-aware-vulnerability-scanner/js/setup-npm-dependencies-for-analysis.js
 var import_lodash9 = __toESM(require_lodash(), 1);
 import { link, mkdir as mkdir7 } from "fs/promises";
 import { availableParallelism } from "os";
-import { dirname as dirname12, join as join13, resolve as resolve11 } from "path";
+import { dirname as dirname12, join as join14, resolve as resolve11 } from "path";
 var { chunk } = import_lodash9.default;
 var ROOT_PACKAGE_METADATA_NAME = "UNIQUE_ROOT_PACKAGE_METADATA_NAME";
 async function setupDependenciesForAnalysis(subprojectDir, workspaceDir, directDependencies, artifactIdToArtifact) {
@@ -110309,7 +110438,7 @@ async function hardlinkPackages(placements) {
       const files = await getFiles(dir, ["node_modules"]);
       for (const sourceFile of files) {
         const relativePath = sourceFile.slice(dir.length + 1);
-        const targetFile = join13(targetPath, relativePath);
+        const targetFile = join14(targetPath, relativePath);
         await mkdir7(dirname12(targetFile), { recursive: true });
         await link(sourceFile, targetFile);
       }
@@ -110553,7 +110682,7 @@ function tarjanAndCondensation(packageMetadatas) {
 
 // dist/whole-program-code-aware-vulnerability-scanner/js/dependency-preparation.js
 async function prepareNpmDependencies(subprojectDir, workspaceDir, artifactIdToArtifact, directDependencies, packageNamesToInstall) {
-  if (existsSync9(resolve12(subprojectDir, "node_modules")))
+  if (existsSync10(resolve12(subprojectDir, "node_modules")))
     return { failedPackages: [], installedPackages: [] };
   const artifactToOriginal = /* @__PURE__ */ new Map();
   const transitiveDependenciesToInstall = Object.fromEntries(Object.entries(artifactIdToArtifact).filter(([_, dep]) => packageNamesToInstall.includes(getPackageName(dep))).map(([depId, dep]) => {
@@ -110638,11 +110767,11 @@ function computePackagesOnVulnPath(vulnerabilities, { includeLeafPackages = fals
 // dist/whole-program-code-aware-vulnerability-scanner/js/jelly-runner.js
 var import_lodash10 = __toESM(require_lodash(), 1);
 import assert4 from "assert";
-import { readFile as readFile8, realpath as realpath2, rm as rm2, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile8, realpath as realpath2, rm as rm2, writeFile as writeFile7 } from "fs/promises";
 import { relative as relative6, resolve as resolve13 } from "path";
 var { map: map2, uniq: uniq4 } = import_lodash10.default;
 var PRINT_JELLY_COMMAND = false;
-async function runJellyAnalysis(mainProjectRoot, projectRoot, jellyOptions, reachabilityAnalysisOptions, timeoutInSeconds, vulnerabilities, experiment, telemetryHandler) {
+async function runJellyAnalysis(mainProjectRoot, projectRoot, jellyOptions, reachabilityAnalysisOptions, timeoutInSeconds, vulnerabilities, experiment, telemetryHandler, analyzerTelemetryHandler) {
   const tmpFolder = await createTmpDirectory("jelly-analysis");
   try {
     const filesToAnalyze = reachabilityAnalysisOptions.entryPoints ?? [projectRoot];
@@ -110660,7 +110789,7 @@ async function runJellyAnalysis(mainProjectRoot, projectRoot, jellyOptions, reac
     const callStackFile = resolve13(tmpFolder, "call-stacks.json");
     const affectedPackagesFile = resolve13(tmpFolder, "affected-packages.json");
     const logFile = reachabilityAnalysisOptions.analysisLogFile ?? (reachabilityAnalysisOptions.printLogFile && resolve13(projectRoot, "js-analysis.log"));
-    await writeFile6(vulnerabilitiesFile, JSON.stringify(vulnerabilitiesInJellyFormat));
+    await writeFile7(vulnerabilitiesFile, JSON.stringify(vulnerabilitiesInJellyFormat));
     const useLazy = experiment === "LAZY_EXPERIMENT" || reachabilityAnalysisOptions.lazy;
     const { includePackages } = jellyOptions;
     const jellyCmd = cmdt`
@@ -110690,7 +110819,8 @@ async function runJellyAnalysis(mainProjectRoot, projectRoot, jellyOptions, reac
         timeout: timeoutInSeconds * 1e3 * 1.5,
         killSignal: "SIGKILL",
         heartbeat: HEARTBEATS.js,
-        telemetryHandler
+        telemetryHandler,
+        analyzerTelemetryHandler
       }
     );
     if (reachabilityAnalysisOptions.printLogFile)
@@ -110724,7 +110854,7 @@ async function runJellyAnalysis(mainProjectRoot, projectRoot, jellyOptions, reac
     await rm2(tmpFolder, { recursive: true });
   }
 }
-async function runJellyPhantomDependencyAnalysis(projectRoot, options, telemetryHandler) {
+async function runJellyPhantomDependencyAnalysis(projectRoot, options, telemetryHandler, analyzerTelemetryHandler) {
   const tmpFolder = await createTmpDirectory("jelly-analysis");
   try {
     const jellyExecutable = ToolPathResolver.jellyPath;
@@ -110736,14 +110866,15 @@ async function runJellyPhantomDependencyAnalysis(projectRoot, options, telemetry
       timeout: options.timeoutSeconds.allVulnRuns * 1e3,
       killSignal: "SIGKILL",
       heartbeat: HEARTBEATS.js,
-      telemetryHandler
+      telemetryHandler,
+      analyzerTelemetryHandler
     });
     return JSON.parse(await readFile8(reachablePackagesFile, "utf-8")).packages;
   } finally {
     await rm2(tmpFolder, { recursive: true });
   }
 }
-async function runJellyImportReachabilityAnalysis(mainProjectRoot, projectRoot, vulnerabilities, options, telemetryHandler) {
+async function runJellyImportReachabilityAnalysis(mainProjectRoot, projectRoot, vulnerabilities, options, telemetryHandler, analyzerTelemetryHandler) {
   const tmpFolder = await createTmpDirectory("jelly-analysis");
   try {
     const includePackages = computePackagesOnVulnPath(vulnerabilities, { includeLeafPackages: true });
@@ -110758,7 +110889,8 @@ async function runJellyImportReachabilityAnalysis(mainProjectRoot, projectRoot,
       timeout: options.timeoutSeconds.allVulnRuns * 1e3,
       killSignal: "SIGKILL",
       heartbeat: HEARTBEATS.js,
-      telemetryHandler
+      telemetryHandler,
+      analyzerTelemetryHandler
     });
     return JSON.parse(await readFile8(reachableModulesFile, "utf-8"));
   } finally {
@@ -110813,11 +110945,11 @@ var JSCodeAwareVulnerabilityScanner = class _JSCodeAwareVulnerabilityScanner {
     const { failedPackages } = await prepareNpmDependencies(state.rootWorkingDir, this.projectDir, state.workspaceData.type === "coana" ? state.workspaceData.data.dependencyTree.transitiveDependencies : Object.fromEntries(state.workspaceData.data.artifacts.map((d) => [d.id, d])), state.workspaceData.type === "coana" ? state.workspaceData.data.dependencyTree.dependencies ?? [] : state.workspaceData.data.artifacts.filter((a2) => a2.direct).map((a2) => a2.id), packagesToInstall);
     this.packagesExcludedUnrelatedToHeuristic = failedPackages.map((p) => getPackageName(p));
   }
-  async runAnalysis(vulnerabilities, heuristic, timeoutInSeconds, experiment, telemetryHandler) {
+  async runAnalysis(vulnerabilities, heuristic, timeoutInSeconds, experiment, telemetryHandler, analyzerTelemetryHandler) {
     const analysisOptionsFromHeuristic = heuristic.getOptions(vulnerabilities);
     try {
       analysisOptionsFromHeuristic.approx = process.env.JELLY_APPROX === "true" || experiment === "JELLY_APPROX";
-      const analysisRes = await runJellyAnalysis(this.mainProjectDir, this.projectDir, analysisOptionsFromHeuristic, this.options, timeoutInSeconds, vulnerabilities, experiment, telemetryHandler);
+      const analysisRes = await runJellyAnalysis(this.mainProjectDir, this.projectDir, analysisOptionsFromHeuristic, this.options, timeoutInSeconds, vulnerabilities, experiment, telemetryHandler, analyzerTelemetryHandler);
       const { analysisDiagnostics: diagnostics, matches } = analysisRes;
       return {
         type: "success",
@@ -110855,7 +110987,7 @@ var JSCodeAwareVulnerabilityScanner = class _JSCodeAwareVulnerabilityScanner {
   }
   static async runOnAlreadyDownloadedPackages(packages, vulnerability, reachabilityAnalysisOptions, baseHeuristic = heuristics.ALL_PACKAGES) {
     return await withTmpDirectory("runOnAlreadyDownloadedPackagesNpm", async (tmpDir) => {
-      const nodeModulesDir = join14(tmpDir, "node_modules");
+      const nodeModulesDir = join15(tmpDir, "node_modules");
       await mkdir8(nodeModulesDir);
       let firstPackageName;
       const fileMappings = /* @__PURE__ */ new Map();
@@ -110871,14 +111003,14 @@ var JSCodeAwareVulnerabilityScanner = class _JSCodeAwareVulnerabilityScanner {
           firstPackageName = nameFromPackageJson;
         else
           otherPackageNames.push(nameFromPackageJson);
-        const targetDirectory = join14(nodeModulesDir, nameFromPackageJson);
+        const targetDirectory = join15(nodeModulesDir, nameFromPackageJson);
         logger.info(`Copying ${packagePath} to ${targetDirectory}`);
         await cp5(packagePath, targetDirectory, { recursive: true });
         fileMappings.set(targetDirectory, packagePath);
       }
       if (!firstPackageName)
         throw new Error("No packages provided to run the analysis on");
-      const projectDir = join14(tmpDir, "node_modules", firstPackageName);
+      const projectDir = join15(tmpDir, "node_modules", firstPackageName);
       const scanner = new _JSCodeAwareVulnerabilityScanner(projectDir, projectDir, reachabilityAnalysisOptions);
       logger.info(`Started analysis of ${projectDir}`);
       const result = await scanner.runAnalysis([vulnerability], heuristics.createIncludePackagesHeuristic(otherPackageNames, baseHeuristic.getOptions([vulnerability])), reachabilityAnalysisOptions.timeoutSeconds.allVulnRuns);
@@ -110898,12 +111030,12 @@ var JSCodeAwareVulnerabilityScanner = class _JSCodeAwareVulnerabilityScanner {
   static async runOnDependencyChain(dependencyChain, vulnerability, reachabilityAnalysisOptions, baseHeuristic = heuristics.ALL_PACKAGES) {
     const [first2, ...rest] = dependencyChain;
     const packageJSONContent = buildPackageJSONForDependencyChain(first2, rest);
-    const tmpDir = mkdtempSync(join14(tmpdir3(), "run-on-dependency-chain"));
-    const packageJsonFileLoc = join14(tmpDir, "package.json");
-    await writeFile7(packageJsonFileLoc, JSON.stringify(packageJSONContent));
+    const tmpDir = mkdtempSync(join15(tmpdir4(), "run-on-dependency-chain"));
+    const packageJsonFileLoc = join15(tmpDir, "package.json");
+    await writeFile8(packageJsonFileLoc, JSON.stringify(packageJSONContent));
     await exec2("npm install -f --ignore-scripts", tmpDir);
     const restWithoutLast = rest.slice(0, -1);
-    const projectDir = join14(tmpDir, "node_modules", first2.packageName);
+    const projectDir = join15(tmpDir, "node_modules", first2.packageName);
     const scanner = new _JSCodeAwareVulnerabilityScanner(tmpDir, projectDir, reachabilityAnalysisOptions);
     const result = await scanner.runAnalysis([vulnerability], heuristics.createIncludePackagesHeuristic(restWithoutLast.map((p) => p.packageName), baseHeuristic.getOptions([vulnerability])), reachabilityAnalysisOptions.timeoutSeconds.allVulnRuns);
     await rm3(tmpDir, { recursive: true, force: true });
@@ -110949,7 +111081,7 @@ function transformSourceLocations(fileMappings, detectedOccurrences) {
       const matchingFile = [...fileMappings.keys()].find((file) => call.sourceLocation.filename.includes(file));
       if (!matchingFile)
         return;
-      const newFilePath = join14(fileMappings.get(matchingFile), call.sourceLocation.filename.split(matchingFile)[1]);
+      const newFilePath = join15(fileMappings.get(matchingFile), call.sourceLocation.filename.split(matchingFile)[1]);
       call.sourceLocation.filename = newFilePath;
     });
   });
@@ -110959,10 +111091,10 @@ function transformSourceLocations(fileMappings, detectedOccurrences) {
 // dist/whole-program-code-aware-vulnerability-scanner/go/go-code-aware-vulnerability-scanner.js
 var import_lodash11 = __toESM(require_lodash(), 1);
 import assert5 from "assert";
-import { existsSync as existsSync10, createReadStream as createReadStream2, createWriteStream as createWriteStream3 } from "fs";
+import { existsSync as existsSync11, createReadStream as createReadStream2, createWriteStream as createWriteStream3 } from "fs";
 import { readFile as readFile9, rm as rm4, cp as cp6 } from "fs/promises";
 import zlib2 from "zlib";
-import { join as join15, resolve as resolve14, sep as sep3 } from "path";
+import { join as join16, resolve as resolve14, sep as sep3 } from "path";
 
 // dist/whole-program-code-aware-vulnerability-scanner/go/heuristics.js
 var GoanaHeuristics = {
@@ -110996,22 +111128,22 @@ var GoCodeAwareVulnerabilityScanner = class {
     this.projectDir = projectDir;
     this.options = options;
   }
-  async runAnalysis(vulns, heuristic, timeoutInSeconds, _experiment, telemetryHandler) {
+  async runAnalysis(vulns, heuristic, timeoutInSeconds, _experiment, telemetryHandler, analyzerTelemetryHandler) {
     logger.info("Started instantiating Go code-aware analysis");
-    if (!existsSync10(join15(this.projectDir, "go.mod")))
+    if (!existsSync11(join16(this.projectDir, "go.mod")))
       throw new Error("go.mod file not found in the project directory");
     const { memoryLimitInMB } = this.options;
     const tmpDir = await createTmpDirectory("goana-output");
-    const vulnsOutputFile = join15(tmpDir, "vulns.json");
-    const diagnosticsOutputFile = join15(tmpDir, "diagnostics.json");
-    const reachedModulesOutputFile = join15(tmpDir, "reached-modules.json");
+    const vulnsOutputFile = join16(tmpDir, "vulns.json");
+    const diagnosticsOutputFile = join16(tmpDir, "diagnostics.json");
+    const reachedModulesOutputFile = join16(tmpDir, "reached-modules.json");
     try {
       const binaryPath = ToolPathResolver.getGoanaBinaryPath(process.platform, process.arch);
       if (!await exists(binaryPath))
         throw new Error(`goana binary not found at '${binaryPath}'`);
-      await pipeline2(createReadStream2(binaryPath), zlib2.createGunzip(), createWriteStream3(join15(tmpDir, "goana"), { mode: 493 }));
+      await pipeline2(createReadStream2(binaryPath), zlib2.createGunzip(), createWriteStream3(join16(tmpDir, "goana"), { mode: 493 }));
       const vulnAccPaths = uniq5(vulns.flatMap((v) => v.vulnerabilityAccessPaths));
-      const { error, stderr } = await execNeverFail2(cmdt`${join15(tmpDir, "goana")}
+      const { error, stderr } = await execNeverFail2(cmdt`${join16(tmpDir, "goana")}
           -output-vulnerabilities ${vulnsOutputFile}
           -output-diagnostics ${diagnosticsOutputFile}
           -output-reached-modules ${reachedModulesOutputFile}
@@ -111021,7 +111153,8 @@ var GoCodeAwareVulnerabilityScanner = class {
         killSignal: "SIGKILL",
         env: memoryLimitInMB ? { ...process.env, GOMEMLIMIT: `${memoryLimitInMB}MiB` } : void 0,
         heartbeat: HEARTBEATS.go,
-        telemetryHandler
+        telemetryHandler,
+        analyzerTelemetryHandler
       });
       if (error) {
         logger.error("Error running Go code-aware analysis", error);
@@ -111072,7 +111205,7 @@ ${stderr}`);
     try {
       await cp6(Dir, projectDir, { recursive: true });
       const projGoMod = resolve14(projectDir, "go.mod");
-      if (!existsSync10(projGoMod))
+      if (!existsSync11(projGoMod))
         await cp6(GoMod, projGoMod);
       await exec2(cmdt`chmod --recursive +w ${projectDir}`);
       await runGoModTidy(projectDir);
@@ -111100,7 +111233,7 @@ ${stderr}`);
   }
   static async runOnAlreadyDownloadedPackages(packages, vuln, options) {
     for (const pkg of packages)
-      assert5(existsSync10(join15(pkg, "go.mod")), `${pkg} does not contain a go.mod file`);
+      assert5(existsSync11(join16(pkg, "go.mod")), `${pkg} does not contain a go.mod file`);
     const [app, ...dependencies] = packages;
     const projectDir = await createTmpDirectory("go-run-on-already-downloaded-packages-");
     try {
@@ -111138,8 +111271,8 @@ ${stderr}`);
 
 // dist/whole-program-code-aware-vulnerability-scanner/rust/rust-code-aware-vulnerability-scanner.js
 var import_lodash12 = __toESM(require_lodash(), 1);
-import { existsSync as existsSync11 } from "node:fs";
-import { readFile as readFile10, writeFile as writeFile8 } from "node:fs/promises";
+import { existsSync as existsSync12 } from "node:fs";
+import { readFile as readFile10, writeFile as writeFile9 } from "node:fs/promises";
 import { basename as basename10, dirname as dirname14, resolve as resolve15 } from "node:path";
 
 // dist/whole-program-code-aware-vulnerability-scanner/rust/heuristics.js
@@ -111239,7 +111372,7 @@ var RustCodeAwareVulnerabilityScanner = class _RustCodeAwareVulnerabilityScanner
     let appCrateName;
     const appSrc = [];
     const dependencies = {};
-    const appCrateInfo = existsSync11(cargoTomlPath) ? await getCrateInfo(cargoTomlPath) : void 0;
+    const appCrateInfo = existsSync12(cargoTomlPath) ? await getCrateInfo(cargoTomlPath) : void 0;
     if (appCrateInfo?.name) {
       appSrc.push(...i([appCrateInfo.lib, ...appCrateInfo.examples ?? [], ...appCrateInfo.tests ?? []]));
       appCrateName = appCrateInfo.name.replaceAll("-", "_");
@@ -111351,7 +111484,7 @@ var RustCodeAwareVulnerabilityScanner = class _RustCodeAwareVulnerabilityScanner
         const appDependencies = {};
         if (rustDependencyChain[0].src && rustDependencyChain[0].src.length > 0) {
           const appCargoTomlPath = resolve15(rustDependencyChain[0].src[0], "..", "Cargo.toml");
-          if (existsSync11(appCargoTomlPath)) {
+          if (existsSync12(appCargoTomlPath)) {
             const cargoTomlDeps = await extractDependenciesFromCargoToml(appCargoTomlPath);
             for (const [packageName, names] of cargoTomlDeps.entries()) {
               const depId = packageNameToId.get(packageName);
@@ -111378,7 +111511,7 @@ var RustCodeAwareVulnerabilityScanner = class _RustCodeAwareVulnerabilityScanner
           const dependencies = {};
           if (dep.src && dep.src.length > 0) {
             const depCargoTomlPath = resolve15(dep.src[0], "..", "Cargo.toml");
-            if (existsSync11(depCargoTomlPath)) {
+            if (existsSync12(depCargoTomlPath)) {
               const cargoTomlDeps = await extractDependenciesFromCargoToml(depCargoTomlPath);
               for (const [packageName, names] of cargoTomlDeps.entries()) {
                 const transDepId = packageNameToId.get(packageName);
@@ -111418,7 +111551,7 @@ var RustCodeAwareVulnerabilityScanner = class _RustCodeAwareVulnerabilityScanner
       };
       const inputFile = resolve15(tmpDir, "input.json");
       const outputFile = resolve15(tmpDir, "output.json");
-      await writeFile8(inputFile, JSON.stringify(options));
+      await writeFile9(inputFile, JSON.stringify(options));
       const timeoutMs = Math.max(timeoutInSeconds * 1.5, timeoutInSeconds + 30) * 1e3;
       const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runRustDirectDependencyAnalysis -i ${inputFile} -o ${outputFile} --tree-sitter-rust ${getTreeSitterRustPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.rust });
       if (result.error)
@@ -111427,7 +111560,7 @@ var RustCodeAwareVulnerabilityScanner = class _RustCodeAwareVulnerabilityScanner
       return packageIds?.map((packageId) => this.depIdToPurl.get(packageId)?.name).filter((name2) => name2 !== void 0).map((name2) => name2);
     });
   }
-  async runAnalysis(vulnerabilities, heuristic, timeoutInSeconds, _experiment, telemetryHandler) {
+  async runAnalysis(vulnerabilities, heuristic, timeoutInSeconds, _experiment, telemetryHandler, analyzerTelemetryHandler) {
     try {
       this.statusUpdater?.("Preparing code for analysis...");
       const packagesToAnalyze = heuristic.getPackagesToAnalyze(vulnerabilities);
@@ -111436,12 +111569,12 @@ var RustCodeAwareVulnerabilityScanner = class _RustCodeAwareVulnerabilityScanner
         const purl = this.depIdToPurl.get(packageId);
         return purl?.name && packagesToAnalyzeSet.has(purl.name);
       }));
-      return await this.actuallyRunAnalysis(vulnerabilities.flatMap((v) => v.vulnerabilityAccessPaths), timeoutInSeconds, filteredDeps, telemetryHandler);
+      return await this.actuallyRunAnalysis(vulnerabilities.flatMap((v) => v.vulnerabilityAccessPaths), timeoutInSeconds, filteredDeps, telemetryHandler, analyzerTelemetryHandler);
     } catch (e) {
       return { type: "error", message: e.message };
     }
   }
-  async actuallyRunAnalysis(vulnerabilityAccessPaths, timeoutInSeconds, filteredDeps, telemetryHandler) {
+  async actuallyRunAnalysis(vulnerabilityAccessPaths, timeoutInSeconds, filteredDeps, telemetryHandler, analyzerTelemetryHandler) {
     this.statusUpdater?.("Running analysis...");
     return withTmpDirectory("rust-run-analysis", async (tmpDir) => {
       const effectiveTimeout = timeoutInSeconds;
@@ -111454,9 +111587,9 @@ var RustCodeAwareVulnerabilityScanner = class _RustCodeAwareVulnerabilityScanner
       };
       const inputFile = resolve15(tmpDir, "input.json");
       const outputFile = resolve15(tmpDir, "output.json");
-      await writeFile8(inputFile, JSON.stringify(options));
+      await writeFile9(inputFile, JSON.stringify(options));
       const timeoutMs = Math.max(effectiveTimeout * 1.5, effectiveTimeout + 30) * 1e3;
-      const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runRustReachabilityAnalysis -i ${inputFile} -o ${outputFile} --tree-sitter-rust ${getTreeSitterRustPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.rust, telemetryHandler });
+      const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runRustReachabilityAnalysis -i ${inputFile} -o ${outputFile} --tree-sitter-rust ${getTreeSitterRustPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.rust, telemetryHandler, analyzerTelemetryHandler });
       if (result.error)
         return { type: "error", message: result.error.message ?? "unknown error" };
       const { success, error, analysisDiagnostics: diagnostics, vulnerablePaths, reachablePackageIds } = JSON.parse(await readFile10(outputFile, "utf-8")).result;
@@ -111507,7 +111640,7 @@ var RustCodeAwareVulnerabilityScanner = class _RustCodeAwareVulnerabilityScanner
     };
   }
   getPackagesExcludedUnrelatedToHeuristic() {
-    return Object.entries(this.deps).filter(([_, { src, bin }]) => !src?.length && (!bin || bin.some((f2) => !existsSync11(f2)))).map(([packageId]) => this.depIdToPurl.get(packageId)?.name).filter((name2) => name2 !== void 0).map((name2) => name2);
+    return Object.entries(this.deps).filter(([_, { src, bin }]) => !src?.length && (!bin || bin.some((f2) => !existsSync12(f2)))).map(([packageId]) => this.depIdToPurl.get(packageId)?.name).filter((name2) => name2 !== void 0).map((name2) => name2);
   }
 };
 async function convertDependencyChain3(dependencyChain, tmpDir) {
@@ -111539,7 +111672,7 @@ function getCargoLocalRepositoryPaths() {
     // Cargo git dependencies
     { path: resolve15(cargoHome, "git", "checkouts"), type: "git" }
   ];
-  return repositories.filter((repo) => existsSync11(repo.path));
+  return repositories.filter((repo) => existsSync12(repo.path));
 }
 async function findCargoPackageInLocalRepo(repo, packageName, version3, tmpDir) {
   try {
@@ -111579,10 +111712,10 @@ async function findCargoPackageInLocalRepo(repo, packageName, version3, tmpDir)
 }
 async function extractCargoCrate(crateFilePath, packageName, version3, tmpDir) {
   const packageDir = resolve15(tmpDir, `${packageName}-${version3}`);
-  if (existsSync11(packageDir)) {
+  if (existsSync12(packageDir)) {
     try {
       const cargoTomlPath = resolve15(packageDir, "Cargo.toml");
-      if (existsSync11(cargoTomlPath)) {
+      if (existsSync12(cargoTomlPath)) {
         const depCrateInfo = await getCrateInfo(cargoTomlPath);
         return [depCrateInfo.lib];
       }
@@ -111602,7 +111735,7 @@ async function extractCargoCrate(crateFilePath, packageName, version3, tmpDir) {
 }
 async function downloadAndExtractCargoCrate(packageName, version3, tmpDir) {
   const packageFile = resolve15(tmpDir, `${packageName}-${version3}.crate`);
-  if (!existsSync11(packageFile)) {
+  if (!existsSync12(packageFile)) {
     const packageUrl = getUrlForCrate(packageName, version3);
     const success = await downloadFile(packageUrl, packageFile);
     if (!success) {
@@ -111635,7 +111768,7 @@ async function convertSocketArtifacts3(artifacts, tmpDir, artifactNameToId) {
     const dependencies = {};
     if (src && src.length > 0) {
       const cargoTomlPath = resolve15(dirname14(src[0]), "Cargo.toml");
-      if (existsSync11(cargoTomlPath)) {
+      if (existsSync12(cargoTomlPath)) {
         const cargoTomlDeps = await extractDependenciesFromCargoToml(cargoTomlPath);
         for (const [packageName, names] of cargoTomlDeps.entries()) {
           const depArtifactId = artifactNameToId.get(packageName);
@@ -111846,7 +111979,7 @@ async function runWithJSHeuristics(cb) {
 function getCurrentCommitHash(project) {
   const headShaPath = resolve16(COANA_REPOS_PATH(), project, "HEAD_SHA");
   try {
-    const content = readFileSync3(headShaPath, "utf-8").trim();
+    const content = readFileSync4(headShaPath, "utf-8").trim();
     const colonIndex = content.indexOf(":");
     return colonIndex !== -1 ? content.slice(colonIndex + 1) : content;
   } catch {
@@ -111927,7 +112060,7 @@ var PythonCodeAwareVulnerabilityScanner = class {
       logger.info("Done setting up virtual environment");
     }
   }
-  async runAnalysis(vulns, heuristic, timeoutInSeconds, _experiment, telemetryHandler) {
+  async runAnalysis(vulns, heuristic, timeoutInSeconds, _experiment, telemetryHandler, analyzerTelemetryHandler) {
     if (!this.virtualEnvInfo)
       throw new Error("Virtual environment not set up");
     this.mambaladeVenvPath ??= await setupMambalade();
@@ -111954,10 +112087,10 @@ var PythonCodeAwareVulnerabilityScanner = class {
     const packagesToExclude = heuristic.getPackagesToExcludeFromAnalysis?.(vulns);
     const vulnAccPaths = sortedUniq(vulns.flatMap((v) => v.vulnerabilityAccessPaths).sort());
     const tmpDir = await createTmpDirectory("coana-mambalade-output");
-    const vulnsOutputFile = join16(tmpDir, "vulns.json");
-    const diagnosticsOutputFile = join16(tmpDir, "diagnostics.json");
-    const reachedPackagesOutputFile = join16(tmpDir, "reached-packages.json");
-    const pythonExecutable = join16(this.mambaladeVenvPath, "bin", "python");
+    const vulnsOutputFile = join17(tmpDir, "vulns.json");
+    const diagnosticsOutputFile = join17(tmpDir, "diagnostics.json");
+    const reachedPackagesOutputFile = join17(tmpDir, "reached-packages.json");
+    const pythonExecutable = join17(this.mambaladeVenvPath, "bin", "python");
     const mambaladeArgs = cmdt`\
       ${pythonExecutable} - ${reachabilityAnalysisOptions.memoryLimitInMB ?? 0}
       --vulnerabilities ${vulnAccPaths}
@@ -111982,7 +112115,8 @@ var PythonCodeAwareVulnerabilityScanner = class {
         timeout: (timeoutInSeconds * 1.5 + 15) * 1e3,
         killSignal: "SIGKILL",
         heartbeat: HEARTBEATS.python,
-        telemetryHandler
+        telemetryHandler,
+        analyzerTelemetryHandler
       });
       logger.debug("Done running mambalade");
       const errors = stderr.split("\n").filter((line) => line.startsWith("ERROR:") && !/^ERROR: Excluded distribution/.test(line));
@@ -112059,7 +112193,7 @@ ${msg}`;
   static async runOnAlreadyDownloadedPackages([app, ...dependencies], vuln, options) {
     return await withTmpDirectory("runOnAlreadyDownloadedPackagesPIP", async (projectTmpDir) => {
       const fileMappings = /* @__PURE__ */ new Map();
-      const projectDir = join16(projectTmpDir, basename11(app));
+      const projectDir = join17(projectTmpDir, basename11(app));
       logger.info(`Copying ${app} to ${projectDir}`);
       await cp7(app, projectDir, { recursive: true });
       fileMappings.set(projectDir, app);
@@ -112071,7 +112205,7 @@ ${msg}`;
         await scanner.prepareVirtualEnv([]);
         const sitePackagesDir = scanner.virtualEnvInfo.virtualEnvPathToSitePackages;
         for (const dep of dependencies) {
-          const dependencyDir = join16(sitePackagesDir, basename11(dep));
+          const dependencyDir = join17(sitePackagesDir, basename11(dep));
           logger.info(`Copying ${dep} to ${dependencyDir}`);
           await cp7(dep, dependencyDir, { recursive: true });
           fileMappings.set(dependencyDir, dep);
@@ -112108,7 +112242,7 @@ ${msg}`;
             const candidate = findBestWheel(packageName, version3, meta);
             if (candidate) {
               const filename = candidate.url.split("/").at(-1);
-              if (await downloadFile(candidate.url, join16(tmpDir, filename)) && await execAndLogOnFailure2(["unzip", filename], tmpDir, void 0, "debug"))
+              if (await downloadFile(candidate.url, join17(tmpDir, filename)) && await execAndLogOnFailure2(["unzip", filename], tmpDir, void 0, "debug"))
                 return;
             }
             await execUvPipInstall(cmdt`${uvCommand} pip install --python-platform ${uvPythonPlatform} --target ${tmpDir} --no-deps ${packageName}==${version3}`);
@@ -112134,7 +112268,7 @@ ${msg}`;
   // public for testing only
   async tryUsingPreinstalledVirtualEnv(packages) {
     const preinstallVirtualEnvPath = resolve17(this.projectDir, ".venv");
-    if (!existsSync12(preinstallVirtualEnvPath))
+    if (!existsSync13(preinstallVirtualEnvPath))
       return false;
     logger.info(`Checking preinstalled virtual environment at ${preinstallVirtualEnvPath}`);
     try {
@@ -112161,7 +112295,7 @@ ${msg}`;
     if (!await hasUv())
       throw new Error("uv (https://docs.astral.sh/uv/) is missing, but is required for Python analysis");
     const tmpDir = await createTmpDirectory("coana-python-analysis-venv");
-    const virtualEnvFolder = join16(tmpDir, ".venv");
+    const virtualEnvFolder = join17(tmpDir, ".venv");
     const pythonExecutable = await this.vm.getPythonExecutableForWorkspace(this.projectDir, false);
     await exec2(cmdt`${uvCommand} venv --python ${pythonExecutable} .venv`, tmpDir);
     logger.debug("Virtual environment created at", virtualEnvFolder);
@@ -112196,7 +112330,7 @@ ${msg}`;
         if (!candidate)
           return true;
         const filename = candidate.url.split("/").at(-1);
-        if (await downloadFile(candidate.url, join16(tmpDir, filename)) && await execAndLogOnFailure2(cmdt`${uvTool(pythonExecutable)} --from installer==0.7.0 python -m installer
+        if (await downloadFile(candidate.url, join17(tmpDir, filename)) && await execAndLogOnFailure2(cmdt`${uvTool(pythonExecutable)} --from installer==0.7.0 python -m installer
                 --no-compile-bytecode --prefix .venv ${filename}`, tmpDir, void 0, "debug")) {
           installStats.installedUsingSpecializedInstallCommand.push(packageName);
           return false;
@@ -112233,7 +112367,7 @@ ${msg}`;
     await this.updateVirtualEnvInfo(tmpDir, installStats);
   }
   async updateVirtualEnvInfo(virtualEnvFolder, packageInstallationStats) {
-    const entries = await readdir4(join16(virtualEnvFolder, ".venv", "lib"));
+    const entries = await readdir4(join17(virtualEnvFolder, ".venv", "lib"));
     const pydir = entries.find((entry) => entry.startsWith("python"));
     assert6(pydir, `No python* directory found in virtual environment: ${util5.inspect(entries)}`);
     this.virtualEnvInfo = {
@@ -112291,13 +112425,13 @@ function transformSourceLocations2(appPath, fileMappings, detectedOccurrences) {
   for (const stack of detectedOccurrences.stacks)
     for (const call of stack) {
       if (call.package === ROOT_NODE_STR) {
-        call.sourceLocation.filename = join16(dirname15(appPath), call.sourceLocation.filename);
+        call.sourceLocation.filename = join17(dirname15(appPath), call.sourceLocation.filename);
         continue;
       }
       const entry = entries.find(([file]) => call.sourceLocation.filename.includes(file));
       if (entry) {
         const [oldFile, newFile] = entry;
-        const newFilePath = join16(newFile, call.sourceLocation.filename.split(oldFile)[1]);
+        const newFilePath = join17(newFile, call.sourceLocation.filename.split(oldFile)[1]);
         call.sourceLocation.filename = newFilePath;
       }
     }
@@ -112330,7 +112464,7 @@ async function setupMambalade() {
   logger.debug(`Using Python interpreter: ${python}`);
   await exec2(cmdt`${uvCommand} venv --python=${python} ${venvDir}`);
   const mambaladeWheelsPath = ToolPathResolver.mambaladeDistPath;
-  const mambaladeWheels = (await readdir4(mambaladeWheelsPath)).filter((f2) => f2.endsWith(".whl")).map((f2) => join16(mambaladeWheelsPath, f2));
+  const mambaladeWheels = (await readdir4(mambaladeWheelsPath)).filter((f2) => f2.endsWith(".whl")).map((f2) => join17(mambaladeWheelsPath, f2));
   if (!mambaladeWheels.length)
     throw new Error(`No mambalade wheel files found in ${mambaladeWheelsPath}`);
   logger.debug(`Installing mambalade wheels: ${mambaladeWheels.join(", ")}`);
@@ -112753,7 +112887,7 @@ async function analyzeWithHeuristics(state, vulns, heuristicsInOrder, doNotRecom
         const initialBucketContainingAllVulns = buckets.length === 1 && buckets[0] === bucket;
         const timeoutInSeconds = initialBucketContainingAllVulns ? state.reachabilityAnalysisOptions.timeoutSeconds.allVulnRuns : state.reachabilityAnalysisOptions.timeoutSeconds.bucketedRuns;
         logger.info(`Running full reachability analysis for ${vulnsForBucket.length}/${vulnerabilities.length} vulnerabilities.`);
-        const result = await codeAwareScanner.runAnalysis(vulnsForBucket, bucket.heuristic, timeoutInSeconds, experiment, createTelemetryHandler(dashboardAPI, analysisMetadataId));
+        const result = await codeAwareScanner.runAnalysis(vulnsForBucket, bucket.heuristic, timeoutInSeconds, experiment, createTelemetryHandler(dashboardAPI, analysisMetadataId), createAnalyzerTelemetryHandler(dashboardAPI, analysisMetadataId));
         const allowSplitInBuckets = !disableBucketing && bucket.heuristic.splitAnalysisInBuckets && !state.otherAnalysisOptions.disableBucketing && vulnDepIdentifiers.length > 1 && (result.type === "error" || result.reachedDependencies);
         if (result.type === "success") {
           result.diagnostics.timings ??= {};
@@ -113117,7 +113251,7 @@ var MavenAnalyzer = class {
 // dist/analyzers/npm-analyzer.js
 var import_lodash19 = __toESM(require_lodash(), 1);
 var import_picomatch4 = __toESM(require_picomatch2(), 1);
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { rm as rm6 } from "fs/promises";
 import { relative as relative8, resolve as resolve20 } from "path";
 
@@ -113153,7 +113287,7 @@ var NpmAnalyzer = class {
   }
   async runReachabilityAnalysis(vulns, analysisMetadataCollector, statusUpdater) {
     const heuristicsInOrder = this.state.otherAnalysisOptions.lightweightReachability ? [heuristics.IGNORE_DEPENDENCIES_AND_MAX_ROUNDS_3] : [heuristics.ONLY_VULN_PATH_PACKAGES_EXCEPT_VULNERABLE_PACKAGE];
-    const nodeModulesAlreadyExisted = existsSync13(resolve20(this.state.subprojectDir, "node_modules"));
+    const nodeModulesAlreadyExisted = existsSync14(resolve20(this.state.subprojectDir, "node_modules"));
     this.preinstalledDependencies = nodeModulesAlreadyExisted ? "YES" : "NO";
     const wrappedCollector = (metadata) => {
       const jellyDiagnostics = metadata.analysisDiagnostics;
@@ -113176,7 +113310,7 @@ var NpmAnalyzer = class {
       try {
         statusUpdater?.("Running import reachability analysis");
         logger.debug("Starting jelly import reachability analysis");
-        reachable = await runJellyImportReachabilityAnalysis(this.state.rootWorkingDir, this.projectDir, vulns, this.state.reachabilityAnalysisOptions, createTelemetryHandler(dashboardAPI2, importAnalysisMetadataId));
+        reachable = await runJellyImportReachabilityAnalysis(this.state.rootWorkingDir, this.projectDir, vulns, this.state.reachabilityAnalysisOptions, createTelemetryHandler(dashboardAPI2, importAnalysisMetadataId), createAnalyzerTelemetryHandler(dashboardAPI2, importAnalysisMetadataId));
         dashboardAPI2.registerDiagnosticsToAnalysisMetadata(importAnalysisMetadataId, {
           analysisDiagnostics: {
             timeout: false,
@@ -113270,9 +113404,9 @@ ${e.stack}` : String(e),
       return res;
     } finally {
       if (!nodeModulesAlreadyExisted) {
-        if (existsSync13(resolve20(this.state.subprojectDir, "node_modules")))
+        if (existsSync14(resolve20(this.state.subprojectDir, "node_modules")))
           await rm6(resolve20(this.state.subprojectDir, "node_modules"), { recursive: true });
-        if (existsSync13(resolve20(this.projectDir, "node_modules")))
+        if (existsSync14(resolve20(this.projectDir, "node_modules")))
           await rm6(resolve20(this.projectDir, "node_modules"), { recursive: true });
       }
     }
@@ -113359,14 +113493,14 @@ var NugetAnalyzer = class {
 
 // dist/analyzers/ruby-analyzer.js
 var import_lodash21 = __toESM(require_lodash(), 1);
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { resolve as resolve21 } from "path";
 
 // dist/whole-program-code-aware-vulnerability-scanner/ruby/ruby-code-aware-vulnerability-scanner.js
 var import_lodash20 = __toESM(require_lodash(), 1);
-import { createWriteStream as createWriteStream4, existsSync as existsSync14 } from "fs";
+import { createWriteStream as createWriteStream4, existsSync as existsSync15 } from "fs";
 import { mkdir as mkdir9, readdir as readdir5, readFile as readFile12, rm as rm7 } from "fs/promises";
-import { join as join17, relative as relative9 } from "path";
+import { join as join18, relative as relative9 } from "path";
 import { pipeline as pipeline3 } from "stream/promises";
 var PRINT_ANALYSIS_COMMAND = false;
 var { uniqBy: uniqBy2, sortedUniq: sortedUniq2 } = import_lodash20.default;
@@ -113383,8 +113517,8 @@ var RubyCodeAwareVulnerabilityScanner = class {
     this.options = options;
   }
   async prepareDependencies(preInstalledDepInfos, vulns, heuristic) {
-    const vendorDir = join17(this.projectDir, "vendor");
-    if (existsSync14(vendorDir)) {
+    const vendorDir = join18(this.projectDir, "vendor");
+    if (existsSync15(vendorDir)) {
       logger.info(`Vendor directory already exists at ${vendorDir}, skipping gem installation`);
       this.vendorDir = vendorDir;
       this.vendorDirWasCreated = false;
@@ -113418,12 +113552,12 @@ var RubyCodeAwareVulnerabilityScanner = class {
       if (!this.vendorDir)
         throw new Error("Assertion error: The vendor directory is not correctly initialized");
       const analyzerPath = ToolPathResolver.callgraphReachabilityAnalyzersCliPath;
-      if (!existsSync14(analyzerPath))
+      if (!existsSync15(analyzerPath))
         throw new Error(`callgraph-reachability-analyzers CLI not found at ${analyzerPath}`);
       const vulnAccPaths = sortedUniq2(vulns.flatMap((v) => v.vulnerabilityAccessPaths).sort());
-      const vulnsOutputFile = join17(tmpDir, "vulns.json");
-      const reachedPackagesOutputFile = join17(tmpDir, "reached-packages.json");
-      const diagnosticsOutputFile = join17(tmpDir, "diagnostics.json");
+      const vulnsOutputFile = join18(tmpDir, "vulns.json");
+      const reachedPackagesOutputFile = join18(tmpDir, "reached-packages.json");
+      const diagnosticsOutputFile = join18(tmpDir, "diagnostics.json");
       const packagesToAnalyze = heuristic.getPackagesToIncludeInAnalysis?.(vulns);
       const { loadPathsToPackageNames, failedToFindLoadPath } = await this.computeLoadPath(packagesToAnalyze ?? []);
       const loadPaths = Array.from(loadPathsToPackageNames.keys());
@@ -113458,7 +113592,7 @@ var RubyCodeAwareVulnerabilityScanner = class {
           telemetryHandler
         });
         const result = JSON.parse(await readFile12(vulnsOutputFile, "utf-8"));
-        const relativeLoadPathsToPackageNames = new Map([...loadPathsToPackageNames.entries()].map(([k, v]) => [join17("vendor", relative9(this.vendorDir, k)), v]));
+        const relativeLoadPathsToPackageNames = new Map([...loadPathsToPackageNames.entries()].map(([k, v]) => [join18("vendor", relative9(this.vendorDir, k)), v]));
         const { timedOut, ...diagnostics } = JSON.parse(await readFile12(diagnosticsOutputFile, "utf-8"));
         const reachedPackages = JSON.parse(await readFile12(reachedPackagesOutputFile, "utf-8"));
         logger.debug("Reached packages: %O", reachedPackages);
@@ -113491,7 +113625,7 @@ var RubyCodeAwareVulnerabilityScanner = class {
     return this.packagesExcludedUnrelatedToHeuristic;
   }
   async cleanup() {
-    if (this.vendorDirWasCreated && this.vendorDir && existsSync14(this.vendorDir)) {
+    if (this.vendorDirWasCreated && this.vendorDir && existsSync15(this.vendorDir)) {
       logger.info(`Deleting auto-generated vendor directory at ${this.vendorDir}`);
       await rm7(this.vendorDir, { recursive: true, force: true }).catch(() => {
       });
@@ -113506,20 +113640,20 @@ var RubyCodeAwareVulnerabilityScanner = class {
     const failedToFindLoadPath = [];
     if (this.vendorDirWasCreated) {
       for (const pkg of packagesToAnalyze) {
-        const libPath = join17(this.vendorDir, `${pkg.packageName}-${pkg.version}`, "lib");
-        if (existsSync14(libPath))
+        const libPath = join18(this.vendorDir, `${pkg.packageName}-${pkg.version}`, "lib");
+        if (existsSync15(libPath))
           loadPathsToPackageNames.set(libPath, `${pkg.packageName}@${pkg.version}`);
         else
           failedToFindLoadPath.push(pkg);
       }
       return { loadPathsToPackageNames, failedToFindLoadPath };
     }
-    const bundlerGemsDir = join17(this.vendorDir, "bundle", "ruby");
-    if (existsSync14(bundlerGemsDir)) {
+    const bundlerGemsDir = join18(this.vendorDir, "bundle", "ruby");
+    if (existsSync15(bundlerGemsDir)) {
       const rubyVersions = await readdir5(bundlerGemsDir);
       for (const rubyVersion of rubyVersions) {
-        const gemsDir = join17(bundlerGemsDir, rubyVersion, "gems");
-        if (existsSync14(gemsDir)) {
+        const gemsDir = join18(bundlerGemsDir, rubyVersion, "gems");
+        if (existsSync15(gemsDir)) {
           const nameToEntry = /* @__PURE__ */ new Map();
           for (const entry of await readdir5(gemsDir, { withFileTypes: true }))
             if (entry.isDirectory()) {
@@ -113531,8 +113665,8 @@ var RubyCodeAwareVulnerabilityScanner = class {
             const entry = nameToEntry.get(`${pkg.packageName}-${pkg.version}`);
             if (!entry)
               continue;
-            const libDir = join17(gemsDir, entry, "lib");
-            if (existsSync14(libDir))
+            const libDir = join18(gemsDir, entry, "lib");
+            if (existsSync15(libDir))
               loadPathsToPackageNames.set(libDir, `${pkg.packageName}@${pkg.version}`);
             else
               failedToFindLoadPath.push(pkg);
@@ -113541,8 +113675,8 @@ var RubyCodeAwareVulnerabilityScanner = class {
       }
     } else
       for (const pkg of packagesToAnalyze) {
-        const libPath = join17(this.vendorDir, `${pkg.packageName}-${pkg.version}`, "lib");
-        if (existsSync14(libPath))
+        const libPath = join18(this.vendorDir, `${pkg.packageName}-${pkg.version}`, "lib");
+        if (existsSync15(libPath))
           loadPathsToPackageNames.set(libPath, `${pkg.packageName}@${pkg.version}`);
         else
           failedToFindLoadPath.push(pkg);
@@ -113551,12 +113685,12 @@ var RubyCodeAwareVulnerabilityScanner = class {
   }
 };
 async function downloadAndExtractGem(gemName, version3, vendorDir) {
-  const gemDir = join17(vendorDir, `${gemName}-${version3}`);
-  if (existsSync14(gemDir)) {
+  const gemDir = join18(vendorDir, `${gemName}-${version3}`);
+  if (existsSync15(gemDir)) {
     logger.debug(`Gem ${gemName}@${version3} already extracted`);
     return;
   }
-  const tempGemFile = join17(vendorDir, `${gemName}-${version3}.gem`);
+  const tempGemFile = join18(vendorDir, `${gemName}-${version3}.gem`);
   const downloadAndExtract = async (platform7) => {
     logger.debug(`Downloading gem ${gemName}@${version3}`);
     const response = await fetch(`https://rubygems.org/gems/${gemName}-${version3}${platform7 ? `-${platform7}` : ""}.gem`);
@@ -113569,8 +113703,8 @@ async function downloadAndExtractGem(gemName, version3, vendorDir) {
     logger.debug(`Extracting gem ${gemName}@${version3}`);
     await exec2(["tar", "-xf", tempGemFile, "data.tar.gz"], gemDir);
     await exec2(["tar", "-xzf", "data.tar.gz"], gemDir);
-    await rm7(join17(gemDir, "data.tar.gz"));
-    const hasValidStructure = [`${gemName}.gemspec`, "Rakefile", "lib"].some((f2) => existsSync14(join17(gemDir, f2)));
+    await rm7(join18(gemDir, "data.tar.gz"));
+    const hasValidStructure = [`${gemName}.gemspec`, "Rakefile", "lib"].some((f2) => existsSync15(join18(gemDir, f2)));
     if (!hasValidStructure)
       throw new Error(`Invalid gem structure: Could not find ${gemName}.gemspec or Rakefile or lib`);
     await rm7(tempGemFile, { force: true });
@@ -113621,7 +113755,7 @@ var RubyGemsAnalyzer = class {
       }
       analysisMetadataCollector?.(metadata);
     };
-    this.preinstalledDependencies = existsSync15(resolve21(this.projectDir, "vendor")) ? "YES" : "NO";
+    this.preinstalledDependencies = existsSync16(resolve21(this.projectDir, "vendor")) ? "YES" : "NO";
     try {
       return await analyzeWithHeuristics(this.state, vulns, [RubyHeuristics.ONLY_VULN_PATH_PACKAGES], false, await this.prepareScanner(), wrappedCollector, statusUpdater);
     } finally {
@@ -113774,7 +113908,7 @@ var runReachabilityAnalysisCmd = new Command().name("runReachabilityAnalysis").a
   const result = await runReachabilityAnalysis(state);
   if (options.outputFile) {
     logger.debug("Writing result to file", options.outputFile);
-    await writeFile9(options.outputFile, JSON.stringify({ result }));
+    await writeFile10(options.outputFile, JSON.stringify({ result }));
   } else {
     logger.info("Result:", JSON.stringify(result, null, 2));
   }
@@ -113788,7 +113922,7 @@ var runOnDependencyChainCmd = new Command().name("runOnDependencyChain").option(
   const result = await analyzePackages(ecosystem, deserializeDependencyChain(ecosystem, dependencyChain), vulnerability, defaultOptions2);
   if (options.outputFile) {
     logger.debug("Writing result to file", options.outputFile);
-    await writeFile9(options.outputFile, JSON.stringify({ result }));
+    await writeFile10(options.outputFile, JSON.stringify({ result }));
   } else {
     logger.info("Result:", JSON.stringify(result, null, 2));
   }
@@ -113821,7 +113955,7 @@ var runOnPackageRegistryPackageCmd = new Command().name("runOnPackageRegistryPac
     const result = isFile3 ? await analyzeAlreadyInstalledPackages(options.ecosystem, [mainPackage, ...options.dependencies].map((p) => p.replace("file://", "")), vulnerability, reachabilityOptions) : await analyzePackages(options.ecosystem, deserializeDependencyChain(options.ecosystem, `${mainPackage}${options.dependencies.length > 0 ? ` > ${options.dependencies.join(" > ")}` : ""}`), vulnerability, reachabilityOptions);
     if (options.outputFile) {
       logger.info("Writing result to file", options.outputFile);
-      await writeFile9(options.outputFile, JSON.stringify(result, null, 2));
+      await writeFile10(options.outputFile, JSON.stringify(result, null, 2));
     } else {
       logger.info("Result:", JSON.stringify(result, null, 2));
     }