@probelabs/visor 0.1.96 → 0.1.97

package/dist/sdk/{chunk-Q4S5A5TO.mjs → chunk-4VK6WTYU.mjs}

@@ -1,7 +1,7 @@
 import {
   init_tracer_init,
   initializeTracer
-} from "./chunk-KVHVCGY6.mjs";
+} from "./chunk-YXOWIDEF.mjs";
 import {
   MemoryStore,
   createExtendedLiquid,
@@ -19,7 +19,7 @@ import {
   emitNdjsonSpanWithEvents,
   fallback_ndjson_exports,
   init_fallback_ndjson
-} from "./chunk-TWJKAYT6.mjs";
+} from "./chunk-IG3BFIIN.mjs";
 import {
   __esm,
   __export,
@@ -139,7 +139,7 @@ var init_session_registry = __esm({
           });
           if (sourceAgent.debug && checkName) {
             try {
-              const { initializeTracer: initializeTracer2 } = await import("./tracer-init-O7RLXMJ3.mjs");
+              const { initializeTracer: initializeTracer2 } = await import("./tracer-init-RJGAIOBP.mjs");
               const tracerResult = await initializeTracer2(newSessionId, checkName);
               if (tracerResult) {
                 clonedAgent.tracer = tracerResult.tracer;
@@ -1864,12 +1864,14 @@ ${"=".repeat(60)}
       }
       if (traceFilePath && telemetryConfig) {
         try {
-          if (tracer && typeof tracer.flush === "function") {
-            await tracer.flush();
+          const telemetry = telemetryConfig;
+          const tracerWithMethods = tracer;
+          if (tracerWithMethods && typeof tracerWithMethods.flush === "function") {
+            await tracerWithMethods.flush();
             log(`\u{1F504} Flushed tracer spans`);
           }
-          if (telemetryConfig && typeof telemetryConfig.shutdown === "function") {
-            await telemetryConfig.shutdown();
+          if (telemetry && typeof telemetry.shutdown === "function") {
+            await telemetry.shutdown();
             log(`\u{1F4CA} OpenTelemetry trace saved to: ${traceFilePath}`);
             if (process.env.GITHUB_ACTIONS) {
               const fs5 = __require("fs");
@@ -1880,8 +1882,8 @@ ${"=".repeat(60)}
                 );
               }
             }
-          } else if (tracer && typeof tracer.shutdown === "function") {
-            await tracer.shutdown();
+          } else if (tracerWithMethods && typeof tracerWithMethods.shutdown === "function") {
+            await tracerWithMethods.shutdown();
             log(`\u{1F4CA} Trace saved to: ${traceFilePath}`);
           }
         } catch (exportError) {
@@ -2275,7 +2277,7 @@ var PRReviewer = class {
   async reviewPR(owner, repo, prNumber, prInfo, options = {}) {
     const { debug = false, config, checks } = options;
     if (config && checks && checks.length > 0) {
-      const { CheckExecutionEngine: CheckExecutionEngine2 } = await import("./check-execution-engine-NMPXJ7FQ.mjs");
+      const { CheckExecutionEngine: CheckExecutionEngine2 } = await import("./check-execution-engine-S7BFPVWA.mjs");
       const engine = new CheckExecutionEngine2();
       const { results } = await engine.executeGroupedChecks(
         prInfo,
@@ -6908,6 +6910,586 @@ var MemoryCheckProvider = class extends CheckProvider {
   }
 };
 
+// src/providers/mcp-check-provider.ts
+init_logger();
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import Sandbox4 from "@nyariv/sandboxjs";
+var McpCheckProvider = class extends CheckProvider {
+  liquid;
+  sandbox;
+  constructor() {
+    super();
+    this.liquid = createExtendedLiquid({
+      cache: false,
+      strictFilters: false,
+      strictVariables: false
+    });
+  }
+  /**
+   * Create a secure sandbox for JavaScript execution
+   * - Uses Sandbox.SAFE_GLOBALS which excludes: Function, eval, require, process, etc.
+   * - Only allows explicitly whitelisted prototype methods
+   * - No access to filesystem, network, or system resources
+   */
+  createSecureSandbox() {
+    const log2 = (...args) => {
+      logger.debug(`[transform_js] ${args.map((a) => JSON.stringify(a)).join(" ")}`);
+    };
+    const globals = {
+      ...Sandbox4.SAFE_GLOBALS,
+      // Excludes Function, eval, require, process, etc.
+      Math,
+      JSON,
+      console: {
+        log: log2
+      }
+    };
+    const prototypeWhitelist = new Map(Sandbox4.SAFE_PROTOTYPES);
+    const arrayMethods = /* @__PURE__ */ new Set([
+      "some",
+      "every",
+      "filter",
+      "map",
+      "reduce",
+      "find",
+      "includes",
+      "indexOf",
+      "length",
+      "slice",
+      "concat",
+      "join",
+      "push",
+      "pop",
+      "shift",
+      "unshift",
+      "sort",
+      "reverse",
+      "flat",
+      "flatMap"
+    ]);
+    prototypeWhitelist.set(Array.prototype, arrayMethods);
+    const stringMethods = /* @__PURE__ */ new Set([
+      "toLowerCase",
+      "toUpperCase",
+      "includes",
+      "indexOf",
+      "startsWith",
+      "endsWith",
+      "slice",
+      "substring",
+      "length",
+      "trim",
+      "split",
+      "replace",
+      // String.prototype.replace for text manipulation (e.g., "hello".replace("h", "H"))
+      "match",
+      "padStart",
+      "padEnd"
+    ]);
+    prototypeWhitelist.set(String.prototype, stringMethods);
+    const objectMethods = /* @__PURE__ */ new Set(["hasOwnProperty", "toString", "valueOf", "keys", "values"]);
+    prototypeWhitelist.set(Object.prototype, objectMethods);
+    return new Sandbox4({
+      globals,
+      prototypeWhitelist
+    });
+  }
+  getName() {
+    return "mcp";
+  }
+  getDescription() {
+    return "Call MCP tools directly using stdio, SSE, or Streamable HTTP transport";
+  }
+  async validateConfig(config) {
+    if (!config || typeof config !== "object") {
+      return false;
+    }
+    const cfg = config;
+    if (!cfg.method || typeof cfg.method !== "string") {
+      logger.error("MCP check requires a method name");
+      return false;
+    }
+    const transport = cfg.transport || "stdio";
+    if (transport === "stdio") {
+      if (!cfg.command || typeof cfg.command !== "string") {
+        logger.error("MCP stdio transport requires a command");
+        return false;
+      }
+      if (/[;&|`$(){}[\]]/.test(cfg.command)) {
+        logger.error("MCP stdio command contains potentially unsafe characters");
+        return false;
+      }
+    } else if (transport === "sse" || transport === "http") {
+      if (!cfg.url || typeof cfg.url !== "string") {
+        logger.error(`MCP ${transport} transport requires a URL`);
+        return false;
+      }
+      try {
+        const parsedUrl = new URL(cfg.url);
+        if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+          logger.error(
+            `Invalid URL protocol for MCP ${transport} transport: ${parsedUrl.protocol}. Only http: and https: are allowed.`
+          );
+          return false;
+        }
+      } catch {
+        logger.error(`Invalid URL format for MCP ${transport} transport: ${cfg.url}`);
+        return false;
+      }
+    } else {
+      logger.error(`Invalid MCP transport: ${transport}. Must be 'stdio', 'sse', or 'http'`);
+      return false;
+    }
+    return true;
+  }
+  async execute(prInfo, config, dependencyResults) {
+    const cfg = config;
+    try {
+      const templateContext = {
+        pr: {
+          number: prInfo.number,
+          title: prInfo.title,
+          author: prInfo.author,
+          branch: prInfo.head,
+          base: prInfo.base
+        },
+        files: prInfo.files,
+        fileCount: prInfo.files.length,
+        outputs: this.buildOutputContext(dependencyResults),
+        env: this.getSafeEnvironmentVariables()
+      };
+      let methodArgs = cfg.methodArgs || {};
+      if (cfg.argsTransform) {
+        const rendered = await this.liquid.parseAndRender(cfg.argsTransform, templateContext);
+        try {
+          methodArgs = JSON.parse(rendered);
+        } catch (error) {
+          logger.error(`Failed to parse argsTransform as JSON: ${error}`);
+          return {
+            issues: [
+              {
+                file: "mcp",
+                line: 0,
+                ruleId: "mcp/args_transform_error",
+                message: `Failed to parse argsTransform: ${error instanceof Error ? error.message : "Unknown error"}`,
+                severity: "error",
+                category: "logic"
+              }
+            ]
+          };
+        }
+      }
+      const result = await this.executeMcpMethod(cfg, methodArgs);
+      let finalOutput = result;
+      if (cfg.transform) {
+        try {
+          const transformContext = {
+            ...templateContext,
+            output: result
+          };
+          const rendered = await this.liquid.parseAndRender(cfg.transform, transformContext);
+          try {
+            finalOutput = JSON.parse(rendered.trim());
+          } catch {
+            finalOutput = rendered.trim();
+          }
+        } catch (error) {
+          logger.error(`Failed to apply Liquid transform: ${error}`);
+          return {
+            issues: [
+              {
+                file: "mcp",
+                line: 0,
+                ruleId: "mcp/transform_error",
+                message: `Failed to apply transform: ${error instanceof Error ? error.message : "Unknown error"}`,
+                severity: "error",
+                category: "logic"
+              }
+            ]
+          };
+        }
+      }
+      if (cfg.transform_js) {
+        try {
+          if (!this.sandbox) {
+            this.sandbox = this.createSecureSandbox();
+          }
+          const scope = {
+            output: finalOutput,
+            pr: templateContext.pr,
+            files: templateContext.files,
+            outputs: templateContext.outputs,
+            env: templateContext.env
+          };
+          const exec = this.sandbox.compile(`return (${cfg.transform_js});`);
+          finalOutput = exec(scope).run();
+        } catch (error) {
+          logger.error(`Failed to apply JavaScript transform: ${error}`);
+          return {
+            issues: [
+              {
+                file: "mcp",
+                line: 0,
+                ruleId: "mcp/transform_js_error",
+                message: `Failed to apply JavaScript transform: ${error instanceof Error ? error.message : "Unknown error"}`,
+                severity: "error",
+                category: "logic"
+              }
+            ]
+          };
+        }
+      }
+      const extracted = this.extractIssuesFromOutput(finalOutput);
+      if (extracted) {
+        return {
+          issues: extracted.issues,
+          ...extracted.remainingOutput ? { output: extracted.remainingOutput } : {}
+        };
+      }
+      return {
+        issues: [],
+        ...finalOutput ? { output: finalOutput } : {}
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      logger.error(`MCP check failed: ${errorMessage}`);
+      return {
+        issues: [
+          {
+            file: "mcp",
+            line: 0,
+            ruleId: "mcp/execution_error",
+            message: `MCP check failed: ${errorMessage}`,
+            severity: "error",
+            category: "logic"
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * Execute an MCP method using the configured transport
+   */
+  async executeMcpMethod(config, methodArgs) {
+    const transport = config.transport || "stdio";
+    const timeout = (config.timeout || 60) * 1e3;
+    if (transport === "stdio") {
+      return await this.executeStdioMethod(config, methodArgs, timeout);
+    } else if (transport === "sse") {
+      return await this.executeSseMethod(config, methodArgs, timeout);
+    } else if (transport === "http") {
+      return await this.executeHttpMethod(config, methodArgs, timeout);
+    } else {
+      throw new Error(`Unsupported transport: ${transport}`);
+    }
+  }
+  /**
+   * Generic method to execute MCP method with any transport
+   */
+  async executeWithTransport(transport, config, methodArgs, timeout, transportName) {
+    const client = new Client(
+      {
+        name: "visor-mcp-client",
+        version: "1.0.0"
+      },
+      {
+        capabilities: {}
+      }
+    );
+    try {
+      let timeoutId;
+      try {
+        await Promise.race([
+          client.connect(transport),
+          new Promise((_, reject) => {
+            timeoutId = setTimeout(() => reject(new Error("Connection timeout")), timeout);
+          })
+        ]);
+      } finally {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+      }
+      logger.debug(`Connected to MCP server via ${transportName}`);
+      if (transport instanceof StreamableHTTPClientTransport && transport.sessionId) {
+        logger.debug(`MCP Session ID: ${transport.sessionId}`);
+      }
+      try {
+        const toolsResult = await client.listTools();
+        logger.debug(`Available MCP tools: ${JSON.stringify(toolsResult?.tools || [])}`);
+      } catch (error) {
+        logger.debug(`Could not list MCP tools: ${error}`);
+      }
+      let callTimeoutId;
+      try {
+        const result = await Promise.race([
+          client.callTool({
+            name: config.method,
+            arguments: methodArgs
+          }),
+          new Promise((_, reject) => {
+            callTimeoutId = setTimeout(() => reject(new Error("Request timeout")), timeout);
+          })
+        ]);
+        logger.debug(`MCP method result: ${JSON.stringify(result)}`);
+        return result;
+      } finally {
+        if (callTimeoutId) {
+          clearTimeout(callTimeoutId);
+        }
+      }
+    } finally {
+      try {
+        await client.close();
+      } catch (error) {
+        logger.debug(`Error closing MCP client: ${error}`);
+      }
+    }
+  }
+  /**
+   * Execute MCP method using stdio transport
+   */
+  async executeStdioMethod(config, methodArgs, timeout) {
+    const transport = new StdioClientTransport({
+      command: config.command,
+      args: config.args,
+      env: config.env,
+      cwd: config.workingDirectory
+    });
+    return this.executeWithTransport(
+      transport,
+      config,
+      methodArgs,
+      timeout,
+      `stdio: ${config.command}`
+    );
+  }
+  /**
+   * Execute MCP method using SSE transport
+   */
+  async executeSseMethod(config, methodArgs, timeout) {
+    const requestInit = {};
+    if (config.headers) {
+      requestInit.headers = config.headers;
+    }
+    const transport = new SSEClientTransport(new URL(config.url), {
+      requestInit
+    });
+    return this.executeWithTransport(transport, config, methodArgs, timeout, `SSE: ${config.url}`);
+  }
+  /**
+   * Execute MCP method using Streamable HTTP transport
+   */
+  async executeHttpMethod(config, methodArgs, timeout) {
+    const requestInit = {};
+    if (config.headers) {
+      requestInit.headers = config.headers;
+    }
+    const transport = new StreamableHTTPClientTransport(new URL(config.url), {
+      requestInit,
+      sessionId: config.sessionId
+    });
+    return this.executeWithTransport(
+      transport,
+      config,
+      methodArgs,
+      timeout,
+      `Streamable HTTP: ${config.url}`
+    );
+  }
+  /**
+   * Build output context from dependency results
+   */
+  buildOutputContext(dependencyResults) {
+    if (!dependencyResults) {
+      return {};
+    }
+    const outputs = {};
+    for (const [checkName, result] of dependencyResults) {
+      const summary = result;
+      outputs[checkName] = summary.output !== void 0 ? summary.output : summary;
+    }
+    return outputs;
+  }
+  /**
+   * Get safe environment variables
+   */
+  getSafeEnvironmentVariables() {
+    const safeVars = {};
+    const allowedPrefixes = ["CI_", "GITHUB_", "RUNNER_", "NODE_", "npm_", "PATH", "HOME", "USER"];
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== void 0 && allowedPrefixes.some((prefix) => key.startsWith(prefix))) {
+        safeVars[key] = value;
+      }
+    }
+    safeVars["PWD"] = process.cwd();
+    return safeVars;
+  }
+  /**
+   * Extract issues from MCP output
+   */
+  extractIssuesFromOutput(output) {
+    if (output === null || output === void 0) {
+      return null;
+    }
+    if (typeof output === "string") {
+      try {
+        const parsed = JSON.parse(output);
+        return this.extractIssuesFromOutput(parsed);
+      } catch {
+        return null;
+      }
+    }
+    if (Array.isArray(output)) {
+      const issues = this.normalizeIssueArray(output);
+      if (issues) {
+        return { issues, remainingOutput: void 0 };
+      }
+      return null;
+    }
+    if (typeof output === "object") {
+      const record = output;
+      if (Array.isArray(record.issues)) {
+        const issues = this.normalizeIssueArray(record.issues);
+        if (!issues) {
+          return null;
+        }
+        const remaining = { ...record };
+        delete remaining.issues;
+        return {
+          issues,
+          remainingOutput: Object.keys(remaining).length > 0 ? remaining : void 0
+        };
+      }
+      const singleIssue = this.normalizeIssue(record);
+      if (singleIssue) {
+        return { issues: [singleIssue], remainingOutput: void 0 };
+      }
+    }
+    return null;
+  }
+  /**
+   * Normalize an array of issues
+   */
+  normalizeIssueArray(values) {
+    const normalized = [];
+    for (const value of values) {
+      const issue = this.normalizeIssue(value);
+      if (!issue) {
+        return null;
+      }
+      normalized.push(issue);
+    }
+    return normalized;
+  }
+  /**
+   * Normalize a single issue
+   */
+  normalizeIssue(raw) {
+    if (!raw || typeof raw !== "object") {
+      return null;
+    }
+    const data = raw;
+    const message = this.toTrimmedString(
+      data.message || data.text || data.description || data.summary
+    );
+    if (!message) {
+      return null;
+    }
+    const allowedSeverities = /* @__PURE__ */ new Set(["info", "warning", "error", "critical"]);
+    const severityRaw = this.toTrimmedString(data.severity || data.level || data.priority);
+    let severity = "warning";
+    if (severityRaw) {
+      const lower = severityRaw.toLowerCase();
+      if (allowedSeverities.has(lower)) {
+        severity = lower;
+      }
+    }
+    const allowedCategories = /* @__PURE__ */ new Set([
+      "security",
+      "performance",
+      "style",
+      "logic",
+      "documentation"
+    ]);
+    const categoryRaw = this.toTrimmedString(data.category || data.type || data.group);
+    let category = "logic";
+    if (categoryRaw && allowedCategories.has(categoryRaw.toLowerCase())) {
+      category = categoryRaw.toLowerCase();
+    }
+    const file = this.toTrimmedString(data.file || data.path || data.filename) || "system";
+    const line = this.toNumber(data.line || data.startLine || data.lineNumber) ?? 0;
+    const endLine = this.toNumber(data.endLine || data.end_line || data.stopLine);
+    const suggestion = this.toTrimmedString(data.suggestion);
+    const replacement = this.toTrimmedString(data.replacement);
+    const ruleId = this.toTrimmedString(data.ruleId || data.rule || data.id || data.check) || "mcp";
+    return {
+      file,
+      line,
+      endLine: endLine ?? void 0,
+      ruleId,
+      message,
+      severity,
+      category,
+      suggestion: suggestion || void 0,
+      replacement: replacement || void 0
+    };
+  }
+  toTrimmedString(value) {
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      return trimmed.length > 0 ? trimmed : null;
+    }
+    if (value !== null && value !== void 0 && typeof value.toString === "function") {
+      const converted = String(value).trim();
+      return converted.length > 0 ? converted : null;
+    }
+    return null;
+  }
+  toNumber(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    const num = Number(value);
+    if (Number.isFinite(num)) {
+      return Math.trunc(num);
+    }
+    return null;
+  }
+  getSupportedConfigKeys() {
+    return [
+      "type",
+      "transport",
+      "command",
+      "args",
+      "env",
+      "workingDirectory",
+      "url",
+      "headers",
+      "sessionId",
+      "method",
+      "methodArgs",
+      "argsTransform",
+      "transform",
+      "transform_js",
+      "timeout",
+      "depends_on",
+      "on",
+      "if",
+      "group"
+    ];
+  }
+  async isAvailable() {
+    return true;
+  }
+  getRequirements() {
+    return ["MCP method name specified", "Transport configuration (stdio: command, sse/http: url)"];
+  }
+};
+
 // src/providers/check-provider-registry.ts
 var CheckProviderRegistry = class _CheckProviderRegistry {
   providers = /* @__PURE__ */ new Map();
@@ -6944,6 +7526,13 @@ var CheckProviderRegistry = class _CheckProviderRegistry {
         `Warning: Failed to register ClaudeCodeCheckProvider: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
+    try {
+      this.register(new McpCheckProvider());
+    } catch (error) {
+      console.error(
+        `Warning: Failed to register McpCheckProvider: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
   }
   /**
    * Register a check provider
@@ -7234,7 +7823,7 @@ var DependencyResolver = class {
 };
 
 // src/failure-condition-evaluator.ts
-import Sandbox4 from "@nyariv/sandboxjs";
+import Sandbox5 from "@nyariv/sandboxjs";
 var FailureConditionEvaluator = class _FailureConditionEvaluator {
   sandbox;
   constructor() {
@@ -7244,7 +7833,7 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
    */
   createSecureSandbox() {
     const globals = {
-      ...Sandbox4.SAFE_GLOBALS,
+      ...Sandbox5.SAFE_GLOBALS,
       // Allow Math for calculations
       Math,
       // Allow console for debugging (in controlled environment)
@@ -7254,7 +7843,7 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
         error: console.error
       }
     };
-    const prototypeWhitelist = new Map(Sandbox4.SAFE_PROTOTYPES);
+    const prototypeWhitelist = new Map(Sandbox5.SAFE_PROTOTYPES);
     const arrayMethods = /* @__PURE__ */ new Set([
       "some",
       "every",
@@ -7287,7 +7876,7 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
     prototypeWhitelist.set(String.prototype, stringMethods);
     const objectMethods = /* @__PURE__ */ new Set(["hasOwnProperty", "toString", "valueOf"]);
     prototypeWhitelist.set(Object.prototype, objectMethods);
-    return new Sandbox4({
+    return new Sandbox5({
       globals,
       prototypeWhitelist
     });
@@ -8392,7 +8981,7 @@ Please check your configuration and try again.`
 
 // src/check-execution-engine.ts
 init_logger();
-import Sandbox5 from "@nyariv/sandboxjs";
+import Sandbox6 from "@nyariv/sandboxjs";
 init_fallback_ndjson();
 function getSafeEnvironmentVariables() {
   const safeEnvVars = [
@@ -8470,13 +9059,13 @@ var CheckExecutionEngine = class _CheckExecutionEngine {
   getRoutingSandbox() {
     if (this.routingSandbox) return this.routingSandbox;
     const globals = {
-      ...Sandbox5.SAFE_GLOBALS,
+      ...Sandbox6.SAFE_GLOBALS,
       Math,
       JSON,
       console: { log: console.log }
     };
-    const prototypeWhitelist = new Map(Sandbox5.SAFE_PROTOTYPES);
-    this.routingSandbox = new Sandbox5({ globals, prototypeWhitelist });
+    const prototypeWhitelist = new Map(Sandbox6.SAFE_PROTOTYPES);
+    this.routingSandbox = new Sandbox6({ globals, prototypeWhitelist });
     return this.routingSandbox;
   }
   redact(str, limit = 200) {
@@ -9841,7 +10430,7 @@ ${expr}
       if (!sanitizedSchema) {
         throw new Error("Invalid schema name");
       }
-      const templatePath = path6.join(__dirname, `../output/${sanitizedSchema}/template.liquid`);
+      const templatePath = path6.join(__dirname, `output/${sanitizedSchema}/template.liquid`);
       templateContent = await fs5.readFile(templatePath, "utf-8");
       if (sanitizedSchema === "issue-assistant") {
         enrichAssistantContext = true;
@@ -9898,7 +10487,7 @@ ${expr}
     }
     const finalRendered = rendered.trim();
     try {
-      const { emitMermaidFromMarkdown } = await import("./mermaid-telemetry-LZGDD35I.mjs");
+      const { emitMermaidFromMarkdown } = await import("./mermaid-telemetry-4DUEYCLE.mjs");
       emitMermaidFromMarkdown(checkName, finalRendered, "content");
     } catch {
     }
@@ -12697,4 +13286,4 @@ ${result.value.result.debug.rawResponse}`;
 export {
   CheckExecutionEngine
 };
-//# sourceMappingURL=chunk-Q4S5A5TO.mjs.map
+//# sourceMappingURL=chunk-4VK6WTYU.mjs.map