@probelabs/probe 0.6.0-rc115 → 0.6.0-rc117

package/cjs/agent/ProbeAgent.cjs

@@ -29807,6 +29807,268 @@ var init_simpleTelemetry = __esm({
   }
 });
 
+// src/agent/probeTool.js
+function isSessionCancelled(sessionId) {
+  return activeToolExecutions.get(sessionId)?.cancelled || false;
+}
+function registerToolExecution(sessionId) {
+  if (!sessionId) return;
+  if (!activeToolExecutions.has(sessionId)) {
+    activeToolExecutions.set(sessionId, { cancelled: false });
+  } else {
+    activeToolExecutions.get(sessionId).cancelled = false;
+  }
+}
+function clearToolExecutionData(sessionId) {
+  if (!sessionId) return;
+  if (activeToolExecutions.has(sessionId)) {
+    activeToolExecutions.delete(sessionId);
+    if (process.env.DEBUG === "1") {
+      console.log(`Cleared tool execution data for session: ${sessionId}`);
+    }
+  }
+}
+function createWrappedTools(baseTools) {
+  const wrappedTools = {};
+  if (baseTools.searchTool) {
+    wrappedTools.searchToolInstance = wrapToolWithEmitter(
+      baseTools.searchTool,
+      "search",
+      baseTools.searchTool.execute
+    );
+  }
+  if (baseTools.queryTool) {
+    wrappedTools.queryToolInstance = wrapToolWithEmitter(
+      baseTools.queryTool,
+      "query",
+      baseTools.queryTool.execute
+    );
+  }
+  if (baseTools.extractTool) {
+    wrappedTools.extractToolInstance = wrapToolWithEmitter(
+      baseTools.extractTool,
+      "extract",
+      baseTools.extractTool.execute
+    );
+  }
+  if (baseTools.delegateTool) {
+    wrappedTools.delegateToolInstance = wrapToolWithEmitter(
+      baseTools.delegateTool,
+      "delegate",
+      baseTools.delegateTool.execute
+    );
+  }
+  if (baseTools.bashTool) {
+    wrappedTools.bashToolInstance = wrapToolWithEmitter(
+      baseTools.bashTool,
+      "bash",
+      baseTools.bashTool.execute
+    );
+  }
+  return wrappedTools;
+}
+var import_child_process8, import_util6, import_crypto3, import_events, import_fs4, import_fs5, import_path8, import_glob, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var init_probeTool = __esm({
+  "src/agent/probeTool.js"() {
+    "use strict";
+    init_index();
+    import_child_process8 = require("child_process");
+    import_util6 = require("util");
+    import_crypto3 = require("crypto");
+    import_events = require("events");
+    import_fs4 = __toESM(require("fs"), 1);
+    import_fs5 = require("fs");
+    import_path8 = __toESM(require("path"), 1);
+    import_glob = require("glob");
+    toolCallEmitter = new import_events.EventEmitter();
+    activeToolExecutions = /* @__PURE__ */ new Map();
+    wrapToolWithEmitter = (tool3, toolName, baseExecute) => {
+      return {
+        ...tool3,
+        // Spread schema, description etc.
+        execute: async (params) => {
+          const debug = process.env.DEBUG === "1";
+          const toolSessionId = params.sessionId || (0, import_crypto3.randomUUID)();
+          if (debug) {
+            console.log(`[DEBUG] probeTool: Executing ${toolName} for session ${toolSessionId}`);
+          }
+          registerToolExecution(toolSessionId);
+          let executionError = null;
+          let result = null;
+          try {
+            const toolCallStartData = {
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              name: toolName,
+              args: params,
+              status: "started"
+            };
+            if (debug) {
+              console.log(`[DEBUG] probeTool: Emitting toolCallStart:${toolSessionId}`);
+            }
+            toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallStartData);
+            if (isSessionCancelled(toolSessionId)) {
+              if (debug) {
+                console.log(`Tool execution cancelled before start for ${toolSessionId}`);
+              }
+              throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
+            }
+            result = await baseExecute(params);
+            if (isSessionCancelled(toolSessionId)) {
+              if (debug) {
+                console.log(`Tool execution cancelled after completion for ${toolSessionId}`);
+              }
+              throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
+            }
+          } catch (error2) {
+            executionError = error2;
+            if (debug) {
+              console.error(`[DEBUG] probeTool: Error in ${toolName}:`, error2);
+            }
+          }
+          if (executionError) {
+            const toolCallErrorData = {
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              name: toolName,
+              args: params,
+              error: executionError.message || "Unknown error",
+              status: "error"
+            };
+            if (debug) {
+              console.log(`[DEBUG] probeTool: Emitting toolCall:${toolSessionId} (error)`);
+            }
+            toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallErrorData);
+            throw executionError;
+          } else {
+            if (isSessionCancelled(toolSessionId)) {
+              if (process.env.DEBUG === "1") {
+                console.log(`Tool execution finished but session was cancelled for ${toolSessionId}`);
+              }
+              throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
+            }
+            const toolCallData = {
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              name: toolName,
+              args: params,
+              // Safely preview result
+              resultPreview: typeof result === "string" ? result.length > 200 ? result.substring(0, 200) + "..." : result : result ? JSON.stringify(result).substring(0, 200) + "..." : "No Result",
+              status: "completed"
+            };
+            if (debug) {
+              console.log(`[DEBUG] probeTool: Emitting toolCall:${toolSessionId} (completed)`);
+            }
+            toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallData);
+            return result;
+          }
+        }
+      };
+    };
+    listFilesTool = {
+      execute: async (params) => {
+        const { directory = ".", workingDirectory } = params;
+        const baseCwd = workingDirectory || process.cwd();
+        const secureBaseDir = import_path8.default.resolve(baseCwd);
+        const targetDir = import_path8.default.resolve(secureBaseDir, directory);
+        if (!targetDir.startsWith(secureBaseDir + import_path8.default.sep) && targetDir !== secureBaseDir) {
+          throw new Error("Path traversal attempt detected. Access denied.");
+        }
+        const debug = process.env.DEBUG === "1";
+        if (debug) {
+          console.log(`[DEBUG] Listing files in directory: ${targetDir}`);
+        }
+        try {
+          const files = await import_fs5.promises.readdir(targetDir, { withFileTypes: true });
+          const formatSize = (size) => {
+            if (size < 1024) return `${size}B`;
+            if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}K`;
+            if (size < 1024 * 1024 * 1024) return `${(size / (1024 * 1024)).toFixed(1)}M`;
+            return `${(size / (1024 * 1024 * 1024)).toFixed(1)}G`;
+          };
+          const entries = await Promise.all(files.map(async (file) => {
+            const isDirectory = file.isDirectory();
+            const fullPath = import_path8.default.join(targetDir, file.name);
+            let size = 0;
+            try {
+              const stats = await import_fs5.promises.stat(fullPath);
+              size = stats.size;
+            } catch (statError) {
+              if (debug) {
+                console.log(`[DEBUG] Could not stat file ${file.name}:`, statError.message);
+              }
+            }
+            return {
+              name: file.name,
+              isDirectory,
+              size
+            };
+          }));
+          entries.sort((a3, b3) => {
+            if (a3.isDirectory && !b3.isDirectory) return -1;
+            if (!a3.isDirectory && b3.isDirectory) return 1;
+            return a3.name.localeCompare(b3.name);
+          });
+          const formatted = entries.map((entry) => {
+            const type = entry.isDirectory ? "dir " : "file";
+            const sizeStr = formatSize(entry.size).padStart(8);
+            return `${type} ${sizeStr}  ${entry.name}`;
+          });
+          if (debug) {
+            console.log(`[DEBUG] Found ${entries.length} files/directories in ${targetDir}`);
+          }
+          const header = `${targetDir}:
+`;
+          const output = header + formatted.join("\n");
+          return output;
+        } catch (error2) {
+          throw new Error(`Failed to list files: ${error2.message}`);
+        }
+      }
+    };
+    searchFilesTool = {
+      execute: async (params) => {
+        const { pattern, directory = ".", recursive = true, workingDirectory } = params;
+        if (!pattern) {
+          throw new Error("Pattern is required for file search");
+        }
+        const baseCwd = workingDirectory || process.cwd();
+        const secureBaseDir = import_path8.default.resolve(baseCwd);
+        const targetDir = import_path8.default.resolve(secureBaseDir, directory);
+        if (!targetDir.startsWith(secureBaseDir + import_path8.default.sep) && targetDir !== secureBaseDir) {
+          throw new Error("Path traversal attempt detected. Access denied.");
+        }
+        if (pattern.includes("**/**") || pattern.split("*").length > 10) {
+          throw new Error("Pattern too complex. Please use a simpler glob pattern.");
+        }
+        try {
+          const options = {
+            cwd: targetDir,
+            ignore: ["node_modules/**", ".git/**"],
+            absolute: false
+          };
+          if (!recursive) {
+            options.deep = 1;
+          }
+          const timeoutPromise = new Promise((_2, reject2) => {
+            setTimeout(() => reject2(new Error("Search operation timed out after 10 seconds")), 1e4);
+          });
+          const files = await Promise.race([
+            (0, import_glob.glob)(pattern, options),
+            timeoutPromise
+          ]);
+          const maxResults = 1e3;
+          if (files.length > maxResults) {
+            return files.slice(0, maxResults);
+          }
+          return files;
+        } catch (error2) {
+          throw new Error(`Failed to search files: ${error2.message}`);
+        }
+      }
+    };
+    listFilesToolInstance = wrapToolWithEmitter(listFilesTool, "listFiles", listFilesTool.execute);
+    searchFilesToolInstance = wrapToolWithEmitter(searchFilesTool, "searchFiles", searchFilesTool.execute);
+  }
+});
+
 // src/index.js
 var init_index = __esm({
   "src/index.js"() {
@@ -29824,6 +30086,7 @@ var init_index = __esm({
     init_bash();
     init_ProbeAgent();
     init_simpleTelemetry();
+    init_probeTool();
   }
 });
 
@@ -29946,12 +30209,12 @@ function parseXmlToolCallWithThinking(xmlString, validTools) {
   }
   return parseXmlToolCall(cleanedXmlString, validTools);
 }
-var import_crypto3, implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition;
+var import_crypto4, implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition;
 var init_tools2 = __esm({
   "src/agent/tools.js"() {
     "use strict";
     init_index();
-    import_crypto3 = require("crypto");
+    import_crypto4 = require("crypto");
     init_xmlParsingUtils();
     implementToolDefinition = `
 ## implement
@@ -30030,216 +30293,6 @@ User: Find all markdown files in the docs directory, but only at the top level.
   }
 });
 
-// src/agent/probeTool.js
-function isSessionCancelled(sessionId) {
-  return activeToolExecutions.get(sessionId)?.cancelled || false;
-}
-function registerToolExecution(sessionId) {
-  if (!sessionId) return;
-  if (!activeToolExecutions.has(sessionId)) {
-    activeToolExecutions.set(sessionId, { cancelled: false });
-  } else {
-    activeToolExecutions.get(sessionId).cancelled = false;
-  }
-}
-function clearToolExecutionData(sessionId) {
-  if (!sessionId) return;
-  if (activeToolExecutions.has(sessionId)) {
-    activeToolExecutions.delete(sessionId);
-    if (process.env.DEBUG === "1") {
-      console.log(`Cleared tool execution data for session: ${sessionId}`);
-    }
-  }
-}
-function createWrappedTools(baseTools) {
-  const wrappedTools = {};
-  if (baseTools.searchTool) {
-    wrappedTools.searchToolInstance = wrapToolWithEmitter(
-      baseTools.searchTool,
-      "search",
-      baseTools.searchTool.execute
-    );
-  }
-  if (baseTools.queryTool) {
-    wrappedTools.queryToolInstance = wrapToolWithEmitter(
-      baseTools.queryTool,
-      "query",
-      baseTools.queryTool.execute
-    );
-  }
-  if (baseTools.extractTool) {
-    wrappedTools.extractToolInstance = wrapToolWithEmitter(
-      baseTools.extractTool,
-      "extract",
-      baseTools.extractTool.execute
-    );
-  }
-  if (baseTools.delegateTool) {
-    wrappedTools.delegateToolInstance = wrapToolWithEmitter(
-      baseTools.delegateTool,
-      "delegate",
-      baseTools.delegateTool.execute
-    );
-  }
-  if (baseTools.bashTool) {
-    wrappedTools.bashToolInstance = wrapToolWithEmitter(
-      baseTools.bashTool,
-      "bash",
-      baseTools.bashTool.execute
-    );
-  }
-  return wrappedTools;
-}
-var import_child_process8, import_util6, import_crypto4, import_events, import_fs4, import_fs5, import_path8, import_glob, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
-var init_probeTool = __esm({
-  "src/agent/probeTool.js"() {
-    "use strict";
-    init_index();
-    import_child_process8 = require("child_process");
-    import_util6 = require("util");
-    import_crypto4 = require("crypto");
-    import_events = require("events");
-    import_fs4 = __toESM(require("fs"), 1);
-    import_fs5 = require("fs");
-    import_path8 = __toESM(require("path"), 1);
-    import_glob = require("glob");
-    toolCallEmitter = new import_events.EventEmitter();
-    activeToolExecutions = /* @__PURE__ */ new Map();
-    wrapToolWithEmitter = (tool3, toolName, baseExecute) => {
-      return {
-        ...tool3,
-        // Spread schema, description etc.
-        execute: async (params) => {
-          const debug = process.env.DEBUG === "1";
-          const toolSessionId = params.sessionId || (0, import_crypto4.randomUUID)();
-          if (debug) {
-            console.log(`[DEBUG] probeTool: Executing ${toolName} for session ${toolSessionId}`);
-          }
-          registerToolExecution(toolSessionId);
-          let executionError = null;
-          let result = null;
-          try {
-            const toolCallStartData = {
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              name: toolName,
-              args: params,
-              status: "started"
-            };
-            if (debug) {
-              console.log(`[DEBUG] probeTool: Emitting toolCallStart:${toolSessionId}`);
-            }
-            toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallStartData);
-            if (isSessionCancelled(toolSessionId)) {
-              if (debug) {
-                console.log(`Tool execution cancelled before start for ${toolSessionId}`);
-              }
-              throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
-            }
-            result = await baseExecute(params);
-            if (isSessionCancelled(toolSessionId)) {
-              if (debug) {
-                console.log(`Tool execution cancelled after completion for ${toolSessionId}`);
-              }
-              throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
-            }
-          } catch (error2) {
-            executionError = error2;
-            if (debug) {
-              console.error(`[DEBUG] probeTool: Error in ${toolName}:`, error2);
-            }
-          }
-          if (executionError) {
-            const toolCallErrorData = {
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              name: toolName,
-              args: params,
-              error: executionError.message || "Unknown error",
-              status: "error"
-            };
-            if (debug) {
-              console.log(`[DEBUG] probeTool: Emitting toolCall:${toolSessionId} (error)`);
-            }
-            toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallErrorData);
-            throw executionError;
-          } else {
-            if (isSessionCancelled(toolSessionId)) {
-              if (process.env.DEBUG === "1") {
-                console.log(`Tool execution finished but session was cancelled for ${toolSessionId}`);
-              }
-              throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
-            }
-            const toolCallData = {
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              name: toolName,
-              args: params,
-              // Safely preview result
-              resultPreview: typeof result === "string" ? result.length > 200 ? result.substring(0, 200) + "..." : result : result ? JSON.stringify(result).substring(0, 200) + "..." : "No Result",
-              status: "completed"
-            };
-            if (debug) {
-              console.log(`[DEBUG] probeTool: Emitting toolCall:${toolSessionId} (completed)`);
-            }
-            toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallData);
-            return result;
-          }
-        }
-      };
-    };
-    listFilesTool = {
-      execute: async (params) => {
-        const { directory = ".", workingDirectory } = params;
-        const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = import_path8.default.resolve(baseCwd);
-        const targetDir = import_path8.default.resolve(secureBaseDir, directory);
-        if (!targetDir.startsWith(secureBaseDir + import_path8.default.sep) && targetDir !== secureBaseDir) {
-          throw new Error("Path traversal attempt detected. Access denied.");
-        }
-        try {
-          const files = await listFilesByLevel({
-            directory: targetDir,
-            maxFiles: 100,
-            respectGitignore: !process.env.PROBE_NO_GITIGNORE || process.env.PROBE_NO_GITIGNORE === "",
-            cwd: secureBaseDir
-          });
-          return files;
-        } catch (error2) {
-          throw new Error(`Failed to list files: ${error2.message}`);
-        }
-      }
-    };
-    searchFilesTool = {
-      execute: async (params) => {
-        const { pattern, directory = ".", recursive = true, workingDirectory } = params;
-        if (!pattern) {
-          throw new Error("Pattern is required for file search");
-        }
-        const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = import_path8.default.resolve(baseCwd);
-        const targetDir = import_path8.default.resolve(secureBaseDir, directory);
-        if (!targetDir.startsWith(secureBaseDir + import_path8.default.sep) && targetDir !== secureBaseDir) {
-          throw new Error("Path traversal attempt detected. Access denied.");
-        }
-        try {
-          const options = {
-            cwd: targetDir,
-            ignore: ["node_modules/**", ".git/**"],
-            absolute: false
-          };
-          if (!recursive) {
-            options.deep = 1;
-          }
-          const files = await (0, import_glob.glob)(pattern, options);
-          return files;
-        } catch (error2) {
-          throw new Error(`Failed to search files: ${error2.message}`);
-        }
-      }
-    };
-    listFilesToolInstance = wrapToolWithEmitter(listFilesTool, "listFiles", listFilesTool.execute);
-    searchFilesToolInstance = wrapToolWithEmitter(searchFilesTool, "searchFiles", searchFilesTool.execute);
-  }
-});
-
 // src/agent/mockProvider.js
 function createMockProvider() {
   return {
@@ -41546,13 +41599,14 @@ function tokenize(text) {
   const lexResult = MermaidLexer.tokenize(text);
   return lexResult;
 }
-var Identifier, NumberLiteral, FlowchartKeyword, GraphKeyword, Direction, SubgraphKeyword, EndKeyword, ClassKeyword, StyleKeyword, ClassDefKeyword, Ampersand, Comma, Semicolon, Colon, TripleColon, BiDirectionalArrow, CircleEndLine, CrossEndLine, DottedArrowRight, DottedArrowLeft, ThickArrowRight, ThickArrowLeft, ArrowRight, ArrowLeft, DottedLine, ThickLine, Line, TwoDashes, InvalidArrow, DoubleSquareOpen, DoubleSquareClose, DoubleRoundOpen, DoubleRoundClose, HexagonOpen, HexagonClose, StadiumOpen, StadiumClose, CylinderOpen, CylinderClose, SquareOpen, SquareClose, RoundOpen, RoundClose, DiamondOpen, DiamondClose, AngleOpen, AngleLess, Pipe, QuotedString, MultilineText, Comment, ColorValue, Text, WhiteSpace, Newline, allTokens, MermaidLexer;
+var Identifier, NumberLiteral, FlowchartKeyword, GraphKeyword, Direction, SubgraphKeyword, EndKeyword, ClassKeyword, StyleKeyword, ClassDefKeyword, Ampersand, Comma, Semicolon, Colon, TripleColon, BiDirectionalArrow, CircleEndLine, CrossEndLine, DottedArrowRight, DottedArrowLeft, ThickArrowRight, ThickArrowLeft, ArrowRight, ArrowLeft, DottedLine, ThickLine, Line, TwoDashes, InvalidArrow, DoubleSquareOpen, DoubleSquareClose, DoubleRoundOpen, DoubleRoundClose, HexagonOpen, HexagonClose, StadiumOpen, StadiumClose, CylinderOpen, CylinderClose, SquareOpen, SquareClose, RoundOpen, RoundClose, DiamondOpen, DiamondClose, AngleOpen, AngleLess, Pipe, ForwardSlash, Backslash, QuotedString, MultilineText, Comment, ColorValue, Text, WhiteSpace, Newline, allTokens, MermaidLexer;
 var init_lexer2 = __esm({
   "node_modules/@probelabs/maid/out/diagrams/flowchart/lexer.js"() {
     init_api5();
     Identifier = createToken({
       name: "Identifier",
-      pattern: /[a-zA-Z_][a-zA-Z0-9_-]*/
+      // e.g., id-2, _id, A1, but not A-- (that belongs to an arrow token)
+      pattern: /[a-zA-Z_][a-zA-Z0-9_]*(?:-[a-zA-Z0-9_]+)*/
     });
     NumberLiteral = createToken({
       name: "NumberLiteral",
@@ -41693,6 +41747,8 @@ var init_lexer2 = __esm({
     AngleOpen = createToken({ name: "AngleOpen", pattern: />/ });
     AngleLess = createToken({ name: "AngleLess", pattern: /</ });
     Pipe = createToken({ name: "Pipe", pattern: /\|/ });
+    ForwardSlash = createToken({ name: "ForwardSlash", pattern: /\// });
+    Backslash = createToken({ name: "Backslash", pattern: /\\/ });
     QuotedString = createToken({
       name: "QuotedString",
       // Allow escaped characters within quotes (Mermaid accepts \" inside "...")
@@ -41776,6 +41832,8 @@ var init_lexer2 = __esm({
       DiamondClose,
       AngleOpen,
       AngleLess,
+      ForwardSlash,
+      Backslash,
       Pipe,
       TripleColon,
       Ampersand,
@@ -41968,6 +42026,8 @@ var init_parser2 = __esm({
                     // Allow HTML-like tags (e.g., <br/>) inside labels
                     { ALT: () => this.CONSUME(AngleLess) },
                     { ALT: () => this.CONSUME(AngleOpen) },
+                    { ALT: () => this.CONSUME(ForwardSlash) },
+                    { ALT: () => this.CONSUME(Backslash) },
                     { ALT: () => this.CONSUME(Comma) },
                     { ALT: () => this.CONSUME(Colon) },
                     // HTML entities and ampersands inside labels
@@ -43016,6 +43076,66 @@ ${br.example}`,
       length: len
     };
   }
+  if (inRule("boxBlock") && (err.name === "NoViableAltException" || err.name === "MismatchedTokenException")) {
+    const isMessage = /->|-->>|-->/.test(ltxt);
+    const isNote = /note\s+(left|right|over)/i.test(ltxt);
+    const isActivate = /activate\s+/i.test(ltxt);
+    const isDeactivate = /deactivate\s+/i.test(ltxt);
+    if (isMessage || isNote || isActivate || isDeactivate || tokType === "NoteKeyword" || tokType === "ActivateKeyword" || tokType === "DeactivateKeyword") {
+      const lines2 = text.split(/\r?\n/);
+      const boxLine = Math.max(0, line - 1);
+      let hasEnd = false;
+      let openIdx = -1;
+      for (let i3 = boxLine; i3 >= 0; i3--) {
+        if (/^\s*box\b/.test(lines2[i3] || "")) {
+          openIdx = i3;
+          break;
+        }
+      }
+      if (openIdx !== -1) {
+        for (let i3 = boxLine; i3 < lines2.length; i3++) {
+          if (/^\s*end\s*$/.test(lines2[i3] || "")) {
+            hasEnd = true;
+            break;
+          }
+          if (i3 > boxLine && /^\s*(sequenceDiagram|box|alt|opt|loop|par|rect|critical|break)\b/.test(lines2[i3] || ""))
+            break;
+        }
+      }
+      if (hasEnd) {
+        let hasParticipants = false;
+        for (let i3 = openIdx + 1; i3 < lines2.length; i3++) {
+          const raw = lines2[i3] || "";
+          if (/^\s*end\s*$/.test(raw))
+            break;
+          if (/^\s*(participant|actor)\b/i.test(raw)) {
+            hasParticipants = true;
+            break;
+          }
+        }
+        if (!hasParticipants) {
+          return {
+            line: openIdx + 1,
+            column: 1,
+            severity: "error",
+            code: "SE-BOX-EMPTY",
+            message: "Box block has no participant/actor declarations. Use 'rect' to group messages visually.",
+            hint: "Replace 'box' with 'rect' if you want to group messages:\nrect rgb(240, 240, 255)\n  A->>B: Message\n  Note over A: Info\nend",
+            length: 3
+          };
+        }
+        return {
+          line,
+          column,
+          severity: "error",
+          code: "SE-BOX-INVALID-CONTENT",
+          message: "Box blocks can only contain participant/actor declarations.",
+          hint: 'Move messages, notes, and other statements outside the box block.\nExample:\nbox "Group"\n  participant A\n  participant B\nend\nA->>B: Message',
+          length: len
+        };
+      }
+    }
+  }
   const blockRules = [
     { rule: "altBlock", label: "alt" },
     { rule: "optBlock", label: "opt" },
@@ -43915,9 +44035,15 @@ var init_parser4 = __esm({
           this.CONSUME(BoxKeyword);
           this.OPTION(() => this.SUBRULE(this.lineRemainder));
           this.AT_LEAST_ONE(() => this.CONSUME(Newline3));
-          this.MANY(() => this.SUBRULE(this.line));
+          this.MANY(() => this.OR([
+            { ALT: () => this.SUBRULE(this.participantDecl) },
+            { ALT: () => this.SUBRULE(this.blankLine) }
+          ]));
           this.CONSUME(EndKeyword2);
-          this.AT_LEAST_ONE2(() => this.CONSUME2(Newline3));
+          this.OR2([
+            { ALT: () => this.AT_LEAST_ONE2(() => this.CONSUME2(Newline3)) },
+            { ALT: () => this.CONSUME2(EOF) }
+          ]);
         });
         this.lineRemainder = this.RULE("lineRemainder", () => {
           this.AT_LEAST_ONE(() => this.OR([
@@ -45468,6 +45594,69 @@ function computeFixes(text, errors, level = "safe") {
       edits.push(replaceRange(text, at(e3), e3.length ?? 4, "option"));
       continue;
     }
+    if (is("SE-BOX-EMPTY", e3)) {
+      const lines = text.split(/\r?\n/);
+      const boxIdx = Math.max(0, e3.line - 1);
+      const boxLine = lines[boxIdx] || "";
+      const labelMatch = /^\s*box\s+(.+)$/.exec(boxLine);
+      if (labelMatch) {
+        const indent = boxLine.match(/^\s*/)?.[0] || "";
+        const newLine = `${indent}rect rgb(240, 240, 255)`;
+        edits.push({ start: { line: e3.line, column: 1 }, end: { line: e3.line, column: boxLine.length + 1 }, newText: newLine });
+      }
+      continue;
+    }
+    if (is("SE-BOX-INVALID-CONTENT", e3)) {
+      const lines = text.split(/\r?\n/);
+      const curIdx = Math.max(0, e3.line - 1);
+      const boxRe = /^(\s*)box\b/;
+      let openIdx = -1;
+      let openIndent = "";
+      for (let i3 = curIdx; i3 >= 0; i3--) {
+        const m3 = boxRe.exec(lines[i3] || "");
+        if (m3) {
+          openIdx = i3;
+          openIndent = m3[1] || "";
+          break;
+        }
+      }
+      if (openIdx !== -1) {
+        let endIdx = -1;
+        for (let i3 = openIdx + 1; i3 < lines.length; i3++) {
+          const trimmed = (lines[i3] || "").trim();
+          if (trimmed === "end") {
+            endIdx = i3;
+            break;
+          }
+        }
+        if (endIdx !== -1) {
+          const invalidLines = [];
+          for (let i3 = openIdx + 1; i3 < endIdx; i3++) {
+            const raw = lines[i3] || "";
+            const trimmed = raw.trim();
+            if (trimmed === "")
+              continue;
+            if (!/^\s*(participant|actor)\b/i.test(raw)) {
+              invalidLines.push(i3);
+            }
+          }
+          if (invalidLines.length > 0) {
+            const endIndent = openIndent;
+            const movedContent = invalidLines.map((i3) => {
+              const line = lines[i3] || "";
+              const trimmed = line.trimStart();
+              return endIndent + trimmed;
+            }).join("\n") + "\n";
+            for (let i3 = invalidLines.length - 1; i3 >= 0; i3--) {
+              const idx = invalidLines[i3];
+              edits.push({ start: { line: idx + 1, column: 1 }, end: { line: idx + 2, column: 1 }, newText: "" });
+            }
+            edits.push(insertAt(text, { line: endIdx + 2, column: 1 }, movedContent));
+          }
+        }
+      }
+      continue;
+    }
     if (is("SE-BLOCK-MISSING-END", e3)) {
       const lines = text.split(/\r?\n/);
       const curIdx = Math.max(0, e3.line - 1);
@@ -45748,26 +45937,561 @@ var init_fixes = __esm({
 });
 
 // node_modules/@probelabs/maid/out/renderer/graph-builder.js
+var GraphBuilder;
 var init_graph_builder = __esm({
   "node_modules/@probelabs/maid/out/renderer/graph-builder.js"() {
-  }
-});
-
-// node_modules/lodash/_listCacheClear.js
-var require_listCacheClear = __commonJS({
-  "node_modules/lodash/_listCacheClear.js"(exports2, module2) {
-    function listCacheClear2() {
-      this.__data__ = [];
-      this.size = 0;
-    }
-    module2.exports = listCacheClear2;
-  }
-});
-
-// node_modules/lodash/eq.js
-var require_eq = __commonJS({
-  "node_modules/lodash/eq.js"(exports2, module2) {
-    function eq2(value, other) {
+    GraphBuilder = class {
+      constructor() {
+        this.nodes = /* @__PURE__ */ new Map();
+        this.edges = [];
+        this.nodeCounter = 0;
+        this.edgeCounter = 0;
+        this.subgraphs = [];
+        this.currentSubgraphStack = [];
+        this.classStyles = /* @__PURE__ */ new Map();
+        this.nodeStyles = /* @__PURE__ */ new Map();
+        this.nodeClasses = /* @__PURE__ */ new Map();
+      }
+      build(cst) {
+        this.reset();
+        if (!cst || !cst.children) {
+          return {
+            nodes: [],
+            edges: [],
+            direction: "TD",
+            subgraphs: []
+          };
+        }
+        const direction = this.extractDirection(cst);
+        this.processStatements(cst);
+        return {
+          nodes: Array.from(this.nodes.values()),
+          edges: this.edges,
+          direction,
+          subgraphs: this.subgraphs
+        };
+      }
+      reset() {
+        this.nodes.clear();
+        this.edges = [];
+        this.nodeCounter = 0;
+        this.edgeCounter = 0;
+        this.subgraphs = [];
+        this.currentSubgraphStack = [];
+        this.classStyles.clear();
+        this.nodeStyles.clear();
+        this.nodeClasses.clear();
+      }
+      extractDirection(cst) {
+        const dirToken = cst.children?.Direction?.[0];
+        const dir = dirToken?.image?.toUpperCase();
+        switch (dir) {
+          case "TB":
+          case "TD":
+            return "TD";
+          case "BT":
+            return "BT";
+          case "LR":
+            return "LR";
+          case "RL":
+            return "RL";
+          default:
+            return "TD";
+        }
+      }
+      processStatements(cst) {
+        const statements = cst.children?.statement;
+        if (!statements)
+          return;
+        for (const stmt of statements) {
+          if (stmt.children?.nodeStatement) {
+            this.processNodeStatement(stmt.children.nodeStatement[0]);
+          } else if (stmt.children?.subgraph) {
+            this.processSubgraph(stmt.children.subgraph[0]);
+          } else if (stmt.children?.classDefStatement) {
+            this.processClassDef(stmt.children.classDefStatement[0]);
+          } else if (stmt.children?.classStatement) {
+            this.processClassAssign(stmt.children.classStatement[0]);
+          } else if (stmt.children?.styleStatement) {
+            this.processStyle(stmt.children.styleStatement[0]);
+          }
+        }
+      }
+      processNodeStatement(stmt) {
+        const groups = stmt.children?.nodeOrParallelGroup;
+        const links = stmt.children?.link;
+        if (!groups || groups.length === 0)
+          return;
+        const sourceNodes = this.processNodeGroup(groups[0]);
+        if (groups.length > 1 && links && links.length > 0) {
+          const targetNodes = this.processNodeGroup(groups[1]);
+          const linkInfo = this.extractLinkInfo(links[0]);
+          for (const source of sourceNodes) {
+            for (const target of targetNodes) {
+              this.edges.push({
+                id: `e${this.edgeCounter++}`,
+                source,
+                target,
+                label: linkInfo.label,
+                type: linkInfo.type,
+                markerStart: linkInfo.markerStart,
+                markerEnd: linkInfo.markerEnd
+              });
+            }
+          }
+          for (let i3 = 2; i3 < groups.length; i3++) {
+            const nextNodes = this.processNodeGroup(groups[i3]);
+            const nextLink = links[i3 - 1] ? this.extractLinkInfo(links[i3 - 1]) : linkInfo;
+            for (const source of targetNodes) {
+              for (const target of nextNodes) {
+                this.edges.push({
+                  id: `e${this.edgeCounter++}`,
+                  source,
+                  target,
+                  label: nextLink.label,
+                  type: nextLink.type,
+                  markerStart: nextLink.markerStart,
+                  markerEnd: nextLink.markerEnd
+                });
+              }
+            }
+            targetNodes.length = 0;
+            targetNodes.push(...nextNodes);
+          }
+        }
+      }
+      processNodeGroup(group) {
+        const nodes = group.children?.node;
+        if (!nodes)
+          return [];
+        const nodeIds = [];
+        for (const node of nodes) {
+          const nodeInfo = this.extractNodeInfo(node);
+          if (nodeInfo) {
+            const isSubgraph = this.subgraphs.some((sg) => sg.id === nodeInfo.id);
+            if (!isSubgraph) {
+              if (!this.nodes.has(nodeInfo.id)) {
+                nodeInfo.style = this.computeNodeStyle(nodeInfo.id);
+                this.nodes.set(nodeInfo.id, nodeInfo);
+              } else {
+                const existing = this.nodes.get(nodeInfo.id);
+                if (nodeInfo.shape !== "rectangle" || nodeInfo.label !== nodeInfo.id) {
+                  if (nodeInfo.label !== nodeInfo.id) {
+                    existing.label = nodeInfo.label;
+                  }
+                  if (nodeInfo.shape !== "rectangle") {
+                    existing.shape = nodeInfo.shape;
+                  }
+                }
+                const merged = this.computeNodeStyle(nodeInfo.id);
+                if (Object.keys(merged).length) {
+                  existing.style = { ...existing.style || {}, ...merged };
+                }
+              }
+              if (this.currentSubgraphStack.length) {
+                for (const sgId of this.currentSubgraphStack) {
+                  const subgraph = this.subgraphs.find((s3) => s3.id === sgId);
+                  if (subgraph && !subgraph.nodes.includes(nodeInfo.id)) {
+                    subgraph.nodes.push(nodeInfo.id);
+                  }
+                }
+              }
+            }
+            nodeIds.push(nodeInfo.id);
+          }
+        }
+        return nodeIds;
+      }
+      extractNodeInfo(node) {
+        const children = node.children;
+        if (!children)
+          return null;
+        let id;
+        if (children.nodeId) {
+          id = children.nodeId[0].image;
+          if (children.nodeIdSuffix) {
+            id += children.nodeIdSuffix[0].image;
+          }
+        } else if (children.nodeIdNum) {
+          id = children.nodeIdNum[0].image;
+        } else if (children.Identifier) {
+          id = children.Identifier[0].image;
+        } else {
+          return null;
+        }
+        let shape = "rectangle";
+        let label = id;
+        const shapeNode = children.nodeShape?.[0];
+        if (shapeNode?.children) {
+          const result = this.extractShapeAndLabel(shapeNode);
+          shape = result.shape;
+          if (result.label)
+            label = result.label;
+        }
+        const clsTok = children.nodeClass?.[0];
+        if (clsTok) {
+          const set = this.nodeClasses.get(id) || /* @__PURE__ */ new Set();
+          set.add(clsTok.image);
+          this.nodeClasses.set(id, set);
+        }
+        return { id, label, shape };
+      }
+      extractShapeAndLabel(shapeNode) {
+        const children = shapeNode.children;
+        let shape = "rectangle";
+        let label = "";
+        const contentNodes = children?.nodeContent;
+        if (contentNodes && contentNodes.length > 0) {
+          label = this.extractTextContent(contentNodes[0]);
+        }
+        if (children?.SquareOpen) {
+          shape = "rectangle";
+          const contentNode = children.nodeContent?.[0];
+          if (contentNode) {
+            const c3 = contentNode.children;
+            const tokTypes = ["ForwardSlash", "Backslash", "Identifier", "Text", "NumberLiteral", "RoundOpen", "RoundClose", "AngleLess", "AngleOpen", "Comma", "Colon", "Ampersand", "Semicolon", "TwoDashes", "Line", "ThickLine", "DottedLine"];
+            const toks = [];
+            for (const tt of tokTypes) {
+              const arr = c3[tt];
+              arr?.forEach((t3) => toks.push({ type: tt, t: t3, start: t3.startOffset ?? 0 }));
+            }
+            if (toks.length >= 2) {
+              toks.sort((a3, b3) => a3.start - b3.start);
+              const first2 = toks[0].type;
+              const last2 = toks[toks.length - 1].type;
+              if (first2 === "ForwardSlash" && last2 === "ForwardSlash" || first2 === "Backslash" && last2 === "Backslash") {
+                shape = "parallelogram";
+              } else if (first2 === "ForwardSlash" && last2 === "Backslash") {
+                shape = "trapezoid";
+              } else if (first2 === "Backslash" && last2 === "ForwardSlash") {
+                shape = "trapezoidAlt";
+              }
+            }
+          }
+        } else if (children?.RoundOpen) {
+          shape = "round";
+        } else if (children?.DiamondOpen) {
+          shape = "diamond";
+        } else if (children?.DoubleRoundOpen) {
+          shape = "circle";
+        } else if (children?.StadiumOpen) {
+          shape = "stadium";
+        } else if (children?.HexagonOpen) {
+          shape = "hexagon";
+        } else if (children?.DoubleSquareOpen) {
+          shape = "subroutine";
+        } else if (children?.CylinderOpen) {
+          shape = "cylinder";
+        } else if (children?.TrapezoidOpen) {
+          shape = "trapezoid";
+        } else if (children?.ParallelogramOpen) {
+          shape = "parallelogram";
+        }
+        return { shape, label };
+      }
+      extractTextContent(contentNode) {
+        const children = contentNode.children;
+        if (!children)
+          return "";
+        const tokenTypes = [
+          "Text",
+          "Identifier",
+          "QuotedString",
+          "NumberLiteral",
+          "Ampersand",
+          "Comma",
+          "Colon",
+          "Semicolon",
+          "Dot",
+          "Underscore",
+          "Dash",
+          "ForwardSlash",
+          "Backslash",
+          "AngleLess",
+          "AngleOpen"
+        ];
+        const tokenWithPositions = [];
+        for (const type of tokenTypes) {
+          const tokens = children[type];
+          if (tokens) {
+            for (const token of tokens) {
+              let text = token.image;
+              if (type === "QuotedString" && text.startsWith('"') && text.endsWith('"')) {
+                text = text.slice(1, -1);
+              }
+              if ((type === "ForwardSlash" || type === "Backslash") && tokenWithPositions.length === 0) {
+                continue;
+              }
+              tokenWithPositions.push({
+                text,
+                startOffset: token.startOffset ?? 0,
+                type
+              });
+            }
+          }
+        }
+        tokenWithPositions.sort((a3, b3) => a3.startOffset - b3.startOffset);
+        if (tokenWithPositions.length) {
+          const first2 = tokenWithPositions[0];
+          if (first2.type === "ForwardSlash" || first2.type === "Backslash") {
+            tokenWithPositions.shift();
+          }
+          const last2 = tokenWithPositions[tokenWithPositions.length - 1];
+          if (last2.type === "ForwardSlash" || last2.type === "Backslash") {
+            tokenWithPositions.pop();
+          }
+        }
+        const parts = tokenWithPositions.map((t3) => t3.text);
+        if (children.Space) {
+          return parts.join("");
+        }
+        return parts.join(" ").trim();
+      }
+      extractLinkInfo(link) {
+        const children = link.children;
+        let type = "arrow";
+        let label;
+        let markerStart = "none";
+        let markerEnd = "none";
+        if (children.BiDirectionalArrow) {
+          type = "arrow";
+          markerStart = "arrow";
+          markerEnd = "arrow";
+        } else if (children.CircleEndLine) {
+          type = "open";
+          markerStart = "circle";
+          markerEnd = "circle";
+        } else if (children.CrossEndLine) {
+          type = "open";
+          markerStart = "cross";
+          markerEnd = "cross";
+        } else if (children?.ArrowRight) {
+          type = "arrow";
+          markerEnd = "arrow";
+        } else if (children?.ArrowLeft) {
+          type = "arrow";
+          markerStart = "arrow";
+        } else if (children?.DottedArrowRight) {
+          type = "dotted";
+          markerEnd = "arrow";
+        } else if (children?.DottedArrowLeft) {
+          type = "dotted";
+          markerStart = "arrow";
+        } else if (children?.ThickArrowRight) {
+          type = "thick";
+          markerEnd = "arrow";
+        } else if (children?.ThickArrowLeft) {
+          type = "thick";
+          markerStart = "arrow";
+        } else if (children?.LinkRight || children?.LinkLeft || children?.Line || children?.TwoDashes || children?.DottedLine || children?.ThickLine) {
+          if (children?.DottedLine)
+            type = "dotted";
+          else if (children?.ThickLine)
+            type = "thick";
+          else
+            type = "open";
+        } else if (children?.InvisibleLink) {
+          type = "invisible";
+        }
+        if (markerEnd === "none" && (children?.ArrowRight || children.ThickArrowRight || children.DottedArrowRight)) {
+          markerEnd = "arrow";
+        }
+        if (markerStart === "none" && (children?.ArrowLeft || children.ThickArrowLeft || children.DottedArrowLeft)) {
+          markerStart = "arrow";
+        }
+        const textNode = children?.linkText?.[0];
+        if (textNode) {
+          label = this.extractTextContent(textNode);
+        } else if (children.linkTextInline?.[0]) {
+          label = this.extractTextContent(children.linkTextInline[0]);
+        } else if (children.inlineCarrier?.[0]) {
+          const token = children.inlineCarrier[0];
+          const raw = token.image.trim();
+          if (raw.startsWith("-.") && raw.endsWith(".-")) {
+            type = "dotted";
+          } else if (raw.startsWith("==") && raw.endsWith("==")) {
+            type = "thick";
+          } else if (raw.startsWith("--") && raw.endsWith("--")) {
+          }
+          if (children.ArrowRight || children.DottedArrowRight || children.ThickArrowRight) {
+            markerEnd = "arrow";
+          }
+          if (children.ArrowLeft || children.DottedArrowLeft || children.ThickArrowLeft) {
+            markerStart = "arrow";
+          }
+          const strip = (str) => {
+            if (str.startsWith("-.") && str.endsWith(".-") || str.startsWith("==") && str.endsWith("==") || str.startsWith("--") && str.endsWith("--")) {
+              return str.slice(2, -2).trim();
+            }
+            return str;
+          };
+          label = strip(raw);
+        }
+        return { type, label, markerStart, markerEnd };
+      }
+      processSubgraph(subgraph) {
+        const children = subgraph.children;
+        let id = `subgraph_${this.subgraphs.length}`;
+        let label;
+        const idToken = children?.subgraphId?.[0] || children?.Identifier?.[0];
+        if (idToken) {
+          id = idToken.image;
+        }
+        if (children?.SquareOpen && children?.nodeContent) {
+          label = this.extractTextContent(children.nodeContent[0]);
+        } else if (children.subgraphTitleQ?.[0]) {
+          const qt = children.subgraphTitleQ[0];
+          const img = qt.image;
+          label = img && img.length >= 2 && (img.startsWith('"') || img.startsWith("'")) ? img.slice(1, -1) : img;
+        } else if (children?.subgraphLabel) {
+          label = this.extractTextContent(children.subgraphLabel[0]);
+        }
+        if (!label && id !== `subgraph_${this.subgraphs.length}`) {
+          label = id;
+        }
+        const parent = this.currentSubgraphStack.length ? this.currentSubgraphStack[this.currentSubgraphStack.length - 1] : void 0;
+        const sg = { id, label, nodes: [], parent };
+        this.subgraphs.push(sg);
+        this.currentSubgraphStack.push(id);
+        const statements = children?.subgraphStatement;
+        if (statements) {
+          for (const stmt of statements) {
+            if (stmt.children?.nodeStatement) {
+              this.processNodeStatement(stmt.children.nodeStatement[0]);
+            } else if (stmt.children?.subgraph) {
+              this.processSubgraph(stmt.children.subgraph[0]);
+            }
+          }
+        }
+        this.currentSubgraphStack.pop();
+      }
+      // ---- Styling helpers ----
+      processClassDef(cst) {
+        const idTok = cst.children?.Identifier?.[0];
+        if (!idTok)
+          return;
+        const className = idTok.image;
+        const props = this.collectStyleProps(cst, { skipFirstIdentifier: true });
+        if (Object.keys(props).length) {
+          this.classStyles.set(className, props);
+          for (const [nodeId, classes] of this.nodeClasses.entries()) {
+            if (classes.has(className)) {
+              const node = this.nodes.get(nodeId);
+              if (node) {
+                node.style = { ...node.style || {}, ...this.computeNodeStyle(nodeId) };
+              }
+            }
+          }
+        }
+      }
+      processClassAssign(cst) {
+        const ids = cst.children?.Identifier || [];
+        if (!ids.length)
+          return;
+        const classNameTok = cst.children.className?.[0];
+        const className = classNameTok?.image || ids[ids.length - 1].image;
+        const nodeIds = classNameTok ? ids.slice(0, -1) : ids.slice(0, -1);
+        for (const tok of nodeIds) {
+          const id = tok.image;
+          const set = this.nodeClasses.get(id) || /* @__PURE__ */ new Set();
+          set.add(className);
+          this.nodeClasses.set(id, set);
+          const node = this.nodes.get(id);
+          if (node) {
+            node.style = { ...node.style || {}, ...this.computeNodeStyle(id) };
+          }
+        }
+      }
+      processStyle(cst) {
+        const idTok = cst.children?.Identifier?.[0];
+        if (!idTok)
+          return;
+        const nodeId = idTok.image;
+        const props = this.collectStyleProps(cst, { skipFirstIdentifier: true });
+        if (Object.keys(props).length) {
+          this.nodeStyles.set(nodeId, props);
+          const node = this.nodes.get(nodeId);
+          if (node) {
+            node.style = { ...node.style || {}, ...this.computeNodeStyle(nodeId) };
+          }
+        }
+      }
+      collectStyleProps(cst, opts = {}) {
+        const tokens = [];
+        const ch = cst.children || {};
+        const push = (arr, type = "t") => arr?.forEach((t3) => tokens.push({ text: t3.image, startOffset: t3.startOffset ?? 0, type }));
+        push(ch.Text, "Text");
+        push(ch.Identifier, "Identifier");
+        push(ch.ColorValue, "Color");
+        push(ch.Colon, "Colon");
+        push(ch.Comma, "Comma");
+        push(ch.NumberLiteral, "Number");
+        tokens.sort((a3, b3) => a3.startOffset - b3.startOffset);
+        if (opts.skipFirstIdentifier) {
+          const idx = tokens.findIndex((t3) => t3.type === "Identifier");
+          if (idx >= 0)
+            tokens.splice(idx, 1);
+        }
+        const joined = tokens.map((t3) => t3.text).join("");
+        const props = {};
+        for (const seg of joined.split(",").map((s3) => s3.trim()).filter(Boolean)) {
+          const [k3, v3] = seg.split(":");
+          if (k3 && v3)
+            props[k3.trim()] = v3.trim();
+        }
+        return props;
+      }
+      computeNodeStyle(nodeId) {
+        const out = {};
+        const classes = this.nodeClasses.get(nodeId);
+        if (classes) {
+          for (const c3 of classes) {
+            const s3 = this.classStyles.get(c3);
+            if (s3)
+              Object.assign(out, this.normalizeStyle(s3));
+          }
+        }
+        const direct = this.nodeStyles.get(nodeId);
+        if (direct)
+          Object.assign(out, this.normalizeStyle(direct));
+        return out;
+      }
+      normalizeStyle(s3) {
+        const out = {};
+        for (const [kRaw, vRaw] of Object.entries(s3)) {
+          const k3 = kRaw.trim().toLowerCase();
+          const v3 = vRaw.trim();
+          if (k3 === "stroke-width") {
+            const num = parseFloat(v3);
+            if (!Number.isNaN(num))
+              out.strokeWidth = num;
+          } else if (k3 === "stroke") {
+            out.stroke = v3;
+          } else if (k3 === "fill") {
+            out.fill = v3;
+          }
+        }
+        return out;
+      }
+    };
+  }
+});
+
+// node_modules/lodash/_listCacheClear.js
+var require_listCacheClear = __commonJS({
+  "node_modules/lodash/_listCacheClear.js"(exports2, module2) {
+    function listCacheClear2() {
+      this.__data__ = [];
+      this.size = 0;
+    }
+    module2.exports = listCacheClear2;
+  }
+});
+
+// node_modules/lodash/eq.js
+var require_eq = __commonJS({
+  "node_modules/lodash/eq.js"(exports2, module2) {
+    function eq2(value, other) {
       return value === other || value !== value && other !== other;
     }
     module2.exports = eq2;
@@ -53363,85 +54087,2504 @@ var require_layout = __commonJS({
         }
       });
     }
-    function selectNumberAttrs(obj, attrs) {
-      return _2.mapValues(_2.pick(obj, attrs), Number);
+    function selectNumberAttrs(obj, attrs) {
+      return _2.mapValues(_2.pick(obj, attrs), Number);
+    }
+    function canonicalize(attrs) {
+      var newAttrs = {};
+      _2.forEach(attrs, function(v3, k3) {
+        newAttrs[k3.toLowerCase()] = v3;
+      });
+      return newAttrs;
+    }
+  }
+});
+
+// node_modules/dagre/lib/debug.js
+var require_debug = __commonJS({
+  "node_modules/dagre/lib/debug.js"(exports2, module2) {
+    var _2 = require_lodash2();
+    var util = require_util();
+    var Graph = require_graphlib2().Graph;
+    module2.exports = {
+      debugOrdering
+    };
+    function debugOrdering(g3) {
+      var layerMatrix = util.buildLayerMatrix(g3);
+      var h3 = new Graph({ compound: true, multigraph: true }).setGraph({});
+      _2.forEach(g3.nodes(), function(v3) {
+        h3.setNode(v3, { label: v3 });
+        h3.setParent(v3, "layer" + g3.node(v3).rank);
+      });
+      _2.forEach(g3.edges(), function(e3) {
+        h3.setEdge(e3.v, e3.w, {}, e3.name);
+      });
+      _2.forEach(layerMatrix, function(layer, i3) {
+        var layerV = "layer" + i3;
+        h3.setNode(layerV, { rank: "same" });
+        _2.reduce(layer, function(u3, v3) {
+          h3.setEdge(u3, v3, { style: "invis" });
+          return v3;
+        });
+      });
+      return h3;
+    }
+  }
+});
+
+// node_modules/dagre/lib/version.js
+var require_version2 = __commonJS({
+  "node_modules/dagre/lib/version.js"(exports2, module2) {
+    module2.exports = "0.8.5";
+  }
+});
+
+// node_modules/dagre/index.js
+var require_dagre = __commonJS({
+  "node_modules/dagre/index.js"(exports2, module2) {
+    module2.exports = {
+      graphlib: require_graphlib2(),
+      layout: require_layout(),
+      debug: require_debug(),
+      util: {
+        time: require_util().time,
+        notime: require_util().notime
+      },
+      version: require_version2()
+    };
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/layout.js
+var import_dagre, DagreLayoutEngine;
+var init_layout = __esm({
+  "node_modules/@probelabs/maid/out/renderer/layout.js"() {
+    import_dagre = __toESM(require_dagre(), 1);
+    DagreLayoutEngine = class {
+      constructor() {
+        this.nodeWidth = 120;
+        this.nodeHeight = 50;
+        this.rankSep = 50;
+        this.nodeSep = 50;
+        this.edgeSep = 10;
+      }
+      layout(graph) {
+        const g3 = new import_dagre.default.graphlib.Graph();
+        const hasClusters = !!(graph.subgraphs && graph.subgraphs.length > 0);
+        const dir = this.mapDirection(graph.direction);
+        let ranksep = this.rankSep;
+        let nodesep = this.nodeSep;
+        if (hasClusters) {
+          if (dir === "LR" || dir === "RL") {
+            ranksep += 20;
+            nodesep += 70;
+          } else {
+            ranksep += 70;
+            nodesep += 20;
+          }
+        }
+        const graphConfig = {
+          rankdir: dir,
+          ranksep,
+          nodesep,
+          edgesep: this.edgeSep,
+          marginx: 20,
+          marginy: 20
+        };
+        if (hasClusters && (dir === "LR" || dir === "RL")) {
+          graphConfig.ranker = "longest-path";
+          graphConfig.acyclicer = "greedy";
+        }
+        if (hasClusters) {
+          graphConfig.compound = true;
+        }
+        g3.setGraph(graphConfig);
+        g3.setDefaultEdgeLabel(() => ({}));
+        if (graph.subgraphs && graph.subgraphs.length > 0) {
+          for (const subgraph of graph.subgraphs) {
+            g3.setNode(subgraph.id, { label: subgraph.label || subgraph.id, clusterLabelPos: "top" });
+          }
+        }
+        for (const node of graph.nodes) {
+          const dimensions = this.calculateNodeDimensions(node.label, node.shape);
+          g3.setNode(node.id, {
+            width: dimensions.width,
+            height: dimensions.height,
+            label: node.label,
+            shape: node.shape
+          });
+        }
+        if (graph.subgraphs && graph.subgraphs.length > 0) {
+          for (const subgraph of graph.subgraphs) {
+            for (const nodeId of subgraph.nodes) {
+              if (g3.hasNode(nodeId)) {
+                try {
+                  g3.setParent(nodeId, subgraph.id);
+                } catch {
+                }
+              }
+            }
+            if (subgraph.parent && g3.hasNode(subgraph.parent)) {
+              try {
+                g3.setParent(subgraph.id, subgraph.parent);
+              } catch {
+              }
+            }
+          }
+        }
+        for (const edge of graph.edges) {
+          g3.setEdge(edge.source, edge.target, {
+            label: edge.label,
+            width: edge.label ? edge.label.length * 8 : 0,
+            height: edge.label ? 20 : 0
+          });
+        }
+        import_dagre.default.layout(g3);
+        const graphInfo = g3.graph();
+        const layoutNodes = [];
+        const layoutEdges = [];
+        for (const node of graph.nodes) {
+          const nodeLayout = g3.node(node.id);
+          if (nodeLayout) {
+            layoutNodes.push({
+              ...node,
+              x: nodeLayout.x - nodeLayout.width / 2,
+              y: nodeLayout.y - nodeLayout.height / 2,
+              width: nodeLayout.width,
+              height: nodeLayout.height
+            });
+          }
+        }
+        const layoutSubgraphs = [];
+        if (graph.subgraphs && graph.subgraphs.length > 0) {
+          for (const sg of graph.subgraphs) {
+            const members = layoutNodes.filter((nd) => sg.nodes.includes(nd.id));
+            if (members.length) {
+              const minX = Math.min(...members.map((m3) => m3.x));
+              const minY = Math.min(...members.map((m3) => m3.y));
+              const maxX = Math.max(...members.map((m3) => m3.x + m3.width));
+              const maxY = Math.max(...members.map((m3) => m3.y + m3.height));
+              const pad = 30;
+              layoutSubgraphs.push({
+                id: sg.id,
+                label: sg.label || sg.id,
+                x: minX - pad,
+                y: minY - pad - 18,
+                // space for title
+                width: maxX - minX + pad * 2,
+                height: maxY - minY + pad * 2 + 18,
+                parent: sg.parent
+              });
+            }
+          }
+          const byId = Object.fromEntries(layoutSubgraphs.map((s3) => [s3.id, s3]));
+          for (const sg of layoutSubgraphs) {
+            if (!sg.parent)
+              continue;
+            const p3 = byId[sg.parent];
+            if (!p3)
+              continue;
+            const minX = Math.min(p3.x, sg.x);
+            const minY = Math.min(p3.y, sg.y);
+            const maxX = Math.max(p3.x + p3.width, sg.x + sg.width);
+            const maxY = Math.max(p3.y + p3.height, sg.y + sg.height);
+            p3.x = minX;
+            p3.y = minY;
+            p3.width = maxX - minX;
+            p3.height = maxY - minY;
+          }
+        }
+        const subgraphById = Object.fromEntries(layoutSubgraphs.map((sg) => [sg.id, sg]));
+        for (const edge of graph.edges) {
+          const edgeLayout = g3.edge(edge.source, edge.target);
+          let pts = edgeLayout && Array.isArray(edgeLayout.points) ? edgeLayout.points.slice() : [];
+          const hasNaN = pts.some((p3) => !Number.isFinite(p3.x) || !Number.isFinite(p3.y));
+          const srcSg = subgraphById[edge.source];
+          const dstSg = subgraphById[edge.target];
+          let synthesized = false;
+          if (!pts.length || hasNaN || srcSg || dstSg) {
+            const rankdir = this.mapDirection(graph.direction);
+            const getNode = (id) => {
+              const n3 = g3.node(id);
+              if (!n3)
+                return void 0;
+              return {
+                id,
+                label: n3.label || id,
+                shape: n3.shape || "rectangle",
+                x: n3.x - n3.width / 2,
+                y: n3.y - n3.height / 2,
+                width: n3.width,
+                height: n3.height,
+                style: {}
+              };
+            };
+            const start = srcSg ? this.clusterAnchor(srcSg, rankdir, "out") : this.nodeAnchor(getNode(edge.source), rankdir, "out");
+            const end = dstSg ? this.clusterAnchor(dstSg, rankdir, "in") : this.nodeAnchor(getNode(edge.target), rankdir, "in");
+            if (start && end) {
+              const PAD = 20;
+              const horizontallyAdjacent = srcSg && dstSg && Math.abs(srcSg.x - dstSg.x) > Math.abs(srcSg.y - dstSg.y);
+              const horizontalSubgraphs = horizontallyAdjacent;
+              if (rankdir === "LR" || rankdir === "RL") {
+                const outX = start.x + (rankdir === "LR" ? PAD : -PAD);
+                const inX = end.x + (rankdir === "LR" ? -PAD : PAD);
+                const startOut = { x: srcSg ? outX : start.x, y: start.y };
+                const endPre = { x: dstSg ? inX : end.x, y: end.y };
+                const alpha = 0.68;
+                const midX = startOut.x + (endPre.x - startOut.x) * alpha;
+                const m1 = { x: midX, y: startOut.y };
+                const m22 = { x: midX, y: endPre.y };
+                pts = dstSg ? [start, startOut, m1, m22, endPre] : [start, startOut, m1, m22, endPre, end];
+              } else {
+                if (horizontalSubgraphs && srcSg && dstSg) {
+                  const midY = (srcSg.y + srcSg.height / 2 + dstSg.y + dstSg.height / 2) / 2;
+                  if (srcSg.x < dstSg.x) {
+                    const startX = srcSg.x + srcSg.width;
+                    const endX = dstSg.x;
+                    pts = [{ x: startX, y: midY }, { x: endX, y: midY }];
+                  } else {
+                    const startX = srcSg.x;
+                    const endX = dstSg.x + dstSg.width;
+                    pts = [{ x: startX, y: midY }, { x: endX, y: midY }];
+                  }
+                } else {
+                  const outY = start.y + (rankdir === "TD" ? PAD : -PAD);
+                  const inY = end.y + (rankdir === "TD" ? -PAD : PAD);
+                  const startOut = { x: start.x, y: srcSg ? outY : start.y };
+                  const endPre = { x: end.x, y: dstSg ? inY : end.y };
+                  const alpha = 0.68;
+                  const midY = startOut.y + (endPre.y - startOut.y) * alpha;
+                  const m1 = { x: startOut.x, y: midY };
+                  const m22 = { x: endPre.x, y: midY };
+                  pts = dstSg ? [start, startOut, m1, m22, endPre] : [start, startOut, m1, m22, endPre, end];
+                }
+              }
+              synthesized = true;
+            }
+          }
+          if (pts.length) {
+            layoutEdges.push({ ...edge, points: pts, pathMode: synthesized ? "orthogonal" : "smooth" });
+          }
+        }
+        const rawW = graphInfo.width;
+        const rawH = graphInfo.height;
+        const w3 = Number.isFinite(rawW) && rawW > 0 ? rawW : 800;
+        const h3 = Number.isFinite(rawH) && rawH > 0 ? rawH : 600;
+        return {
+          nodes: layoutNodes,
+          edges: layoutEdges,
+          width: w3,
+          height: h3,
+          subgraphs: layoutSubgraphs
+        };
+      }
+      mapDirection(direction) {
+        switch (direction) {
+          case "TB":
+          case "TD":
+            return "TB";
+          case "BT":
+            return "BT";
+          case "LR":
+            return "LR";
+          case "RL":
+            return "RL";
+          default:
+            return "TB";
+        }
+      }
+      calculateNodeDimensions(label, shape) {
+        const charWidth = 7;
+        const padding = 20;
+        const minWidth = 80;
+        const minHeight = 40;
+        const maxWidth = 240;
+        const lineHeight = 18;
+        const explicitLines = label.split(/<\s*br\s*\/?\s*>/i);
+        const hasExplicitBreaks = explicitLines.length > 1;
+        let width;
+        let lines;
+        if (hasExplicitBreaks) {
+          const maxLineLength = Math.max(...explicitLines.map((line) => line.length));
+          width = Math.min(Math.max(maxLineLength * charWidth + padding * 2, minWidth), maxWidth);
+          lines = explicitLines.length;
+        } else {
+          width = Math.min(Math.max(label.length * charWidth + padding * 2, minWidth), maxWidth);
+          const charsPerLine = Math.max(1, Math.floor((width - padding * 2) / charWidth));
+          lines = Math.ceil(label.length / charsPerLine);
+        }
+        let height = Math.max(lines * lineHeight + padding, minHeight);
+        switch (shape) {
+          case "circle":
+            const size = Math.max(width, height);
+            width = size;
+            height = size;
+            break;
+          case "diamond": {
+            const size2 = Math.max(width, height) * 1.2;
+            width = size2;
+            height = size2;
+            break;
+          }
+          case "hexagon":
+            width *= 1.3;
+            height *= 1.2;
+            break;
+          case "stadium":
+            width *= 1.2;
+            break;
+          case "cylinder":
+            height *= 1.5;
+            break;
+          case "subroutine":
+          case "double":
+            width += 10;
+            height += 10;
+            break;
+          case "parallelogram":
+          case "trapezoid":
+            width *= 1.3;
+            break;
+        }
+        return { width: Math.round(width), height: Math.round(height) };
+      }
+      clusterAnchor(sg, rankdir, mode) {
+        switch (rankdir) {
+          case "LR":
+            return { x: mode === "out" ? sg.x + sg.width : sg.x, y: sg.y + sg.height / 2 };
+          case "RL":
+            return { x: mode === "out" ? sg.x : sg.x + sg.width, y: sg.y + sg.height / 2 };
+          case "BT":
+            return { x: sg.x + sg.width / 2, y: mode === "out" ? sg.y : sg.y + sg.height };
+          case "TB":
+          default:
+            return { x: sg.x + sg.width / 2, y: mode === "out" ? sg.y + sg.height : sg.y };
+        }
+      }
+      nodeAnchor(n3, rankdir, mode) {
+        if (!n3)
+          return { x: 0, y: 0 };
+        switch (rankdir) {
+          case "LR":
+            return { x: mode === "in" ? n3.x : n3.x + n3.width, y: n3.y + n3.height / 2 };
+          case "RL":
+            return { x: mode === "in" ? n3.x + n3.width : n3.x, y: n3.y + n3.height / 2 };
+          case "BT":
+            return { x: n3.x + n3.width / 2, y: mode === "in" ? n3.y + n3.height : n3.y };
+          case "TB":
+          default:
+            return { x: n3.x + n3.width / 2, y: mode === "in" ? n3.y : n3.y + n3.height };
+        }
+      }
+    };
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/arrow-utils.js
+function triangleAtEnd(start, end, color = "#333", length = 8, width = 6) {
+  const vx = end.x - start.x;
+  const vy = end.y - start.y;
+  const len = Math.hypot(vx, vy) || 1;
+  const ux = vx / len;
+  const uy = vy / len;
+  const nx = -uy;
+  const ny = ux;
+  const baseX = end.x - ux * length;
+  const baseY = end.y - uy * length;
+  const p2x = baseX + nx * (width / 2), p2y = baseY + ny * (width / 2);
+  const p3x = baseX - nx * (width / 2), p3y = baseY - ny * (width / 2);
+  return `<path d="M${end.x},${end.y} L${p2x},${p2y} L${p3x},${p3y} Z" fill="${color}" />`;
+}
+function triangleAtStart(first2, second, color = "#333", length = 8, width = 6) {
+  const vx = second.x - first2.x;
+  const vy = second.y - first2.y;
+  const len = Math.hypot(vx, vy) || 1;
+  const ux = vx / len;
+  const uy = vy / len;
+  const nx = -uy;
+  const ny = ux;
+  const tipX = first2.x - ux * length;
+  const tipY = first2.y - uy * length;
+  const p2x = first2.x + nx * (width / 2), p2y = first2.y + ny * (width / 2);
+  const p3x = first2.x - nx * (width / 2), p3y = first2.y - ny * (width / 2);
+  return `<path d="M${tipX},${tipY} L${p2x},${p2y} L${p3x},${p3y} Z" fill="${color}" />`;
+}
+var init_arrow_utils = __esm({
+  "node_modules/@probelabs/maid/out/renderer/arrow-utils.js"() {
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/styles.js
+function buildSharedCss(opts = {}) {
+  const fontFamily = opts.fontFamily || "Arial, sans-serif";
+  const fontSize = opts.fontSize ?? 14;
+  const nodeFill = opts.nodeFill || "#eef0ff";
+  const nodeStroke = opts.nodeStroke || "#3f3f3f";
+  const edgeStroke = opts.edgeStroke || "#555555";
+  return `
+    .node-shape { fill: ${nodeFill}; stroke: ${nodeStroke}; stroke-width: 1px; }
+    .node-label { fill: #333; font-family: ${fontFamily}; font-size: ${fontSize}px; }
+    .edge-path { stroke: ${edgeStroke}; stroke-width: 2px; fill: none; }
+    .edge-label-bg { fill: rgba(232,232,232, 0.8); opacity: 0.5; }
+    .edge-label-text { fill: #333; font-family: ${fontFamily}; font-size: ${Math.max(10, fontSize - 2)}px; }
+
+    /* Cluster (flowchart + sequence blocks) */
+    .cluster-bg { fill: #ffffde; }
+    .cluster-border { fill: none; stroke: #aaaa33; stroke-width: 1px; }
+    .cluster-title-bg { fill: rgba(255,255,255,0.8); }
+    .cluster-label-text { fill: #333; font-family: ${fontFamily}; font-size: 12px; }
+
+    /* Notes */
+    .note { fill: #fff5ad; stroke: #aaaa33; stroke-width: 1px; }
+    .note-text { fill: #333; font-family: ${fontFamily}; font-size: 12px; }
+
+    /* Sequence-specific add-ons (safe for flowcharts too) */
+    .actor-rect { fill: #eaeaea; stroke: #666; stroke-width: 1.5px; }
+    .actor-label { fill: #111; font-family: ${fontFamily}; font-size: 16px; }
+    .lifeline { stroke: #999; stroke-width: 0.5px; }
+    .activation { fill: #f4f4f4; stroke: #666; stroke-width: 1px; }
+    .msg-line { stroke: #333; stroke-width: 1.5px; fill: none; }
+    .msg-line.dotted { stroke-dasharray: 2 2; }
+    .msg-line.thick { stroke-width: 3px; }
+    .msg-label { fill: #333; font-family: ${fontFamily}; font-size: 12px; dominant-baseline: middle; }
+    .msg-label-bg { fill: #ffffff; stroke: #cccccc; stroke-width: 1px; rx: 3; }
+  `;
+}
+var init_styles = __esm({
+  "node_modules/@probelabs/maid/out/renderer/styles.js"() {
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/utils.js
+function escapeXml(text) {
+  return String(text).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function measureText(text, fontSize = 12) {
+  const avg = 0.6 * fontSize;
+  return Math.max(0, Math.round(text.length * avg));
+}
+function palette(index) {
+  if (index < DEFAULT_PALETTE.length)
+    return DEFAULT_PALETTE[index];
+  const i3 = index - DEFAULT_PALETTE.length;
+  const hue = i3 * 47 % 360;
+  return `hsl(${hue} 60% 55%)`;
+}
+function formatNumber(n3) {
+  if (Number.isInteger(n3))
+    return String(n3);
+  return (Math.round(n3 * 100) / 100).toString();
+}
+function formatPercent(value, total) {
+  if (!(total > 0))
+    return "0%";
+  const p3 = value / total * 100;
+  return `${Math.round(p3)}%`;
+}
+var DEFAULT_PALETTE;
+var init_utils4 = __esm({
+  "node_modules/@probelabs/maid/out/renderer/utils.js"() {
+    DEFAULT_PALETTE = [
+      "#ECECFF",
+      "#ffffde",
+      "hsl(80, 100%, 56.2745098039%)",
+      "hsl(240, 100%, 86.2745098039%)",
+      "hsl(60, 100%, 63.5294117647%)",
+      "hsl(80, 100%, 76.2745098039%)",
+      "hsl(300, 100%, 76.2745098039%)",
+      "hsl(180, 100%, 56.2745098039%)",
+      "hsl(0, 100%, 56.2745098039%)",
+      "hsl(300, 100%, 56.2745098039%)",
+      "hsl(150, 100%, 56.2745098039%)",
+      "hsl(0, 100%, 66.2745098039%)"
+    ];
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/block-utils.js
+function blockBackground(x3, y2, width, height, radius = 0) {
+  return `<g class="cluster-bg-layer" transform="translate(${x3},${y2})">
+  <rect class="cluster-bg" x="0" y="0" width="${width}" height="${height}" rx="${radius}"/>
+</g>`;
+}
+function blockOverlay(x3, y2, width, height, title, branchYs = [], titleYOffset = 0, align = "center", branchAlign = "left", radius = 0) {
+  const parts = [];
+  parts.push(`<g class="cluster-overlay" transform="translate(${x3},${y2})">`);
+  parts.push(`<rect class="cluster-border" x="0" y="0" width="${width}" height="${height}" rx="${radius}"/>`);
+  const titleText = title ? escapeXml(title) : "";
+  if (titleText) {
+    const titleW = Math.max(24, measureText(titleText, 12) + 10);
+    const yBg = -2 + titleYOffset;
+    const yText = 11 + titleYOffset;
+    if (align === "left") {
+      const xBg = 6;
+      parts.push(`<rect class="cluster-title-bg" x="${xBg}" y="${yBg}" width="${titleW}" height="18" rx="3"/>`);
+      parts.push(`<text class="cluster-label-text" x="${xBg + 6}" y="${yText}" text-anchor="start">${titleText}</text>`);
+    } else {
+      const xBg = 6;
+      parts.push(`<rect class="cluster-title-bg" x="${xBg}" y="${yBg}" width="${titleW}" height="18" rx="3"/>`);
+      parts.push(`<text class="cluster-label-text" x="${xBg + titleW / 2}" y="${yText}" text-anchor="middle">${titleText}</text>`);
+    }
+  }
+  for (const br of branchYs) {
+    const yRel = br.y - y2;
+    parts.push(`<line x1="0" y1="${yRel}" x2="${width}" y2="${yRel}" class="cluster-border" />`);
+    if (br.title) {
+      const text = escapeXml(br.title);
+      const bw = Math.max(24, measureText(text, 12) + 10);
+      const xBg = 6;
+      parts.push(`<rect class="cluster-title-bg" x="${xBg}" y="${yRel - 10}" width="${bw}" height="18" rx="3"/>`);
+      if (branchAlign === "left") {
+        parts.push(`<text class="cluster-label-text" x="${xBg + 6}" y="${yRel + 1}" text-anchor="start">${text}</text>`);
+      } else {
+        parts.push(`<text class="cluster-label-text" x="${xBg + bw / 2}" y="${yRel + 1}" text-anchor="middle">${text}</text>`);
+      }
+    }
+  }
+  parts.push("</g>");
+  return parts.join("\n");
+}
+var init_block_utils = __esm({
+  "node_modules/@probelabs/maid/out/renderer/block-utils.js"() {
+    init_utils4();
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/svg-generator.js
+var SVGRenderer;
+var init_svg_generator = __esm({
+  "node_modules/@probelabs/maid/out/renderer/svg-generator.js"() {
+    init_arrow_utils();
+    init_styles();
+    init_block_utils();
+    SVGRenderer = class {
+      constructor() {
+        this.padding = 20;
+        this.fontSize = 14;
+        this.fontFamily = "Arial, sans-serif";
+        this.defaultStroke = "#3f3f3f";
+        this.defaultFill = "#eef0ff";
+        this.arrowStroke = "#555555";
+        this.arrowMarkerSize = 9;
+      }
+      render(layout) {
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        for (const n3 of layout.nodes) {
+          minX = Math.min(minX, n3.x);
+          minY = Math.min(minY, n3.y);
+          maxX = Math.max(maxX, n3.x + n3.width);
+          maxY = Math.max(maxY, n3.y + n3.height);
+        }
+        if (layout.subgraphs) {
+          for (const sg of layout.subgraphs) {
+            minX = Math.min(minX, sg.x);
+            minY = Math.min(minY, sg.y);
+            maxX = Math.max(maxX, sg.x + sg.width);
+            maxY = Math.max(maxY, sg.y + sg.height);
+          }
+        }
+        for (const e3 of layout.edges) {
+          if (e3.points)
+            for (const p3 of e3.points) {
+              minX = Math.min(minX, p3.x);
+              minY = Math.min(minY, p3.y);
+              maxX = Math.max(maxX, p3.x);
+              maxY = Math.max(maxY, p3.y);
+            }
+        }
+        if (!isFinite(minX)) {
+          minX = 0;
+        }
+        if (!isFinite(minY)) {
+          minY = 0;
+        }
+        if (!isFinite(maxX)) {
+          maxX = layout.width;
+        }
+        if (!isFinite(maxY)) {
+          maxY = layout.height;
+        }
+        const extraPadX = Math.max(0, -Math.floor(minX) + 1);
+        const extraPadY = Math.max(0, -Math.floor(minY) + 1);
+        const padX = this.padding + extraPadX;
+        const padY = this.padding + extraPadY;
+        const bboxWidth = Math.ceil(maxX) - Math.min(0, Math.floor(minX));
+        const bboxHeight = Math.ceil(maxY) - Math.min(0, Math.floor(minY));
+        const width = bboxWidth + this.padding * 2 + extraPadX;
+        const height = bboxHeight + this.padding * 2 + extraPadY;
+        const elements = [];
+        const overlays = [];
+        elements.push(this.generateDefs());
+        if (layout.subgraphs && layout.subgraphs.length) {
+          const sgs = layout.subgraphs;
+          const order = sgs.slice().sort((a3, b3) => (a3.parent ? 1 : 0) - (b3.parent ? 1 : 0));
+          const map4 = new Map(order.map((o3) => [o3.id, o3]));
+          const depthOf = (sg) => {
+            let d3 = 0;
+            let p3 = sg.parent;
+            while (p3) {
+              d3++;
+              p3 = map4.get(p3)?.parent;
+            }
+            return d3;
+          };
+          const bgs = [];
+          for (const sg of order) {
+            const x3 = sg.x + padX;
+            const y2 = sg.y + padY;
+            bgs.push(blockBackground(x3, y2, sg.width, sg.height, 0));
+            const depth = depthOf(sg);
+            const title = sg.label ? this.escapeXml(sg.label) : void 0;
+            const titleYOffset = 7 + depth * 12;
+            overlays.push(blockOverlay(x3, y2, sg.width, sg.height, title, [], titleYOffset, "center", "left", 0));
+          }
+          elements.push(`<g class="subgraph-bg">${bgs.join("")}</g>`);
+        }
+        const nodeMap = {};
+        for (const n3 of layout.nodes) {
+          nodeMap[n3.id] = { x: n3.x + padX, y: n3.y + padY, width: n3.width, height: n3.height, shape: n3.shape };
+        }
+        if (layout.subgraphs && layout.subgraphs.length) {
+          for (const sg of layout.subgraphs) {
+            nodeMap[sg.id] = { x: sg.x + padX, y: sg.y + padY, width: sg.width, height: sg.height, shape: "rectangle" };
+          }
+        }
+        for (const node of layout.nodes) {
+          elements.push(this.generateNodeWithPad(node, padX, padY));
+        }
+        for (const edge of layout.edges) {
+          const { path: path6, overlay } = this.generateEdge(edge, padX, padY, nodeMap);
+          elements.push(path6);
+          if (overlay)
+            overlays.push(overlay);
+        }
+        const bg = `<rect x="0" y="0" width="${width}" height="${height}" fill="#ffffff" />`;
+        const sharedCss = buildSharedCss({
+          fontFamily: this.fontFamily,
+          fontSize: this.fontSize,
+          nodeFill: this.defaultFill,
+          nodeStroke: this.defaultStroke,
+          edgeStroke: this.arrowStroke
+        });
+        const css = `<style>${sharedCss}</style>`;
+        return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+  ${bg}
+  ${css}
+  ${elements.join("\n  ")}
+  ${overlays.join("\n  ")}
+</svg>`;
+      }
+      buildNodeStyleAttrs(style) {
+        const decs = [];
+        if (style.fill)
+          decs.push(`fill:${style.fill}`);
+        if (style.stroke)
+          decs.push(`stroke:${style.stroke}`);
+        if (style.strokeWidth != null)
+          decs.push(`stroke-width:${style.strokeWidth}`);
+        return decs.length ? `style="${decs.join(";")}"` : "";
+      }
+      buildNodeStrokeStyle(style) {
+        const decs = [];
+        if (style.stroke)
+          decs.push(`stroke:${style.stroke}`);
+        if (style.strokeWidth != null)
+          decs.push(`stroke-width:${style.strokeWidth}`);
+        return decs.length ? `style="${decs.join(";")}"` : "";
+      }
+      generateDefs() {
+        const aw = Math.max(8, this.arrowMarkerSize + 2);
+        const ah = Math.max(8, this.arrowMarkerSize + 2);
+        const arefX = Math.max(6, aw);
+        const arefY = Math.max(4, Math.round(ah / 2));
+        return `<defs>
+    <marker id="arrow" viewBox="0 0 ${aw} ${ah}" markerWidth="${aw}" markerHeight="${ah}" refX="${arefX}" refY="${arefY}" orient="auto" markerUnits="userSpaceOnUse">
+      <path d="M0,0 L0,${ah} L${aw},${arefY} z" fill="${this.arrowStroke}" />
+    </marker>
+    <marker id="circle-marker" viewBox="0 0 9 9" markerWidth="9" markerHeight="9" refX="4.5" refY="4.5" orient="auto" markerUnits="userSpaceOnUse">
+      <circle cx="4.5" cy="4.5" r="4.5" fill="${this.arrowStroke}" />
+    </marker>
+    <marker id="cross-marker" viewBox="0 0 12 12" markerWidth="12" markerHeight="12" refX="6" refY="6" orient="auto" markerUnits="userSpaceOnUse">
+      <path d="M1.5,1.5 L10.5,10.5 M10.5,1.5 L1.5,10.5" stroke="${this.arrowStroke}" stroke-width="2.25" />
+    </marker>
+  </defs>`;
+      }
+      generateNodeWithPad(node, padX, padY) {
+        const x3 = node.x + padX;
+        const y2 = node.y + padY;
+        const cx = x3 + node.width / 2;
+        const cy = y2 + node.height / 2;
+        let shape = "";
+        let labelCenterY = cy;
+        const strokeWidth = node.style?.strokeWidth ?? void 0;
+        const stroke = node.style?.stroke ?? void 0;
+        const fill = node.style?.fill ?? void 0;
+        const styleAttr = this.buildNodeStyleAttrs({ stroke, strokeWidth, fill });
+        switch (node.shape) {
+          case "rectangle":
+            shape = `<rect class="node-shape" ${styleAttr} x="${x3}" y="${y2}" width="${node.width}" height="${node.height}" rx="0" ry="0" />`;
+            break;
+          case "round":
+            shape = `<rect class="node-shape" ${styleAttr} x="${x3}" y="${y2}" width="${node.width}" height="${node.height}" rx="5" ry="5" />`;
+            break;
+          case "stadium":
+            const radius = node.height / 2;
+            shape = `<rect class="node-shape" ${styleAttr} x="${x3}" y="${y2}" width="${node.width}" height="${node.height}" rx="${radius}" ry="${radius}" />`;
+            break;
+          case "circle":
+            const r3 = Math.min(node.width, node.height) / 2;
+            shape = `<circle class="node-shape" ${styleAttr} cx="${cx}" cy="${cy}" r="${r3}" />`;
+            break;
+          case "diamond": {
+            const points = [
+              `${cx},${y2}`,
+              // top
+              `${x3 + node.width},${cy}`,
+              // right
+              `${cx},${y2 + node.height}`,
+              // bottom
+              `${x3},${cy}`
+              // left
+            ].join(" ");
+            shape = `<polygon class="node-shape" ${styleAttr} points="${points}" />`;
+            break;
+          }
+          case "hexagon": {
+            const dx = node.width * 0.25;
+            const points = [
+              `${x3 + dx},${y2}`,
+              // top-left
+              `${x3 + node.width - dx},${y2}`,
+              // top-right
+              `${x3 + node.width},${cy}`,
+              // right
+              `${x3 + node.width - dx},${y2 + node.height}`,
+              // bottom-right
+              `${x3 + dx},${y2 + node.height}`,
+              // bottom-left
+              `${x3},${cy}`
+              // left
+            ].join(" ");
+            shape = `<polygon class="node-shape" ${styleAttr} points="${points}" />`;
+            break;
+          }
+          case "parallelogram": {
+            const skew = node.width * 0.15;
+            const points = [
+              `${x3 + skew},${y2}`,
+              // top-left
+              `${x3 + node.width},${y2}`,
+              // top-right
+              `${x3 + node.width - skew},${y2 + node.height}`,
+              // bottom-right
+              `${x3},${y2 + node.height}`
+              // bottom-left
+            ].join(" ");
+            shape = `<polygon class="node-shape" ${styleAttr} points="${points}" />`;
+            break;
+          }
+          case "trapezoid": {
+            const inset = node.width * 0.15;
+            const points = [
+              `${x3 + inset},${y2}`,
+              // top-left
+              `${x3 + node.width - inset},${y2}`,
+              // top-right
+              `${x3 + node.width},${y2 + node.height}`,
+              // bottom-right
+              `${x3},${y2 + node.height}`
+              // bottom-left
+            ].join(" ");
+            shape = `<polygon class="node-shape" ${styleAttr} points="${points}" />`;
+            break;
+          }
+          case "trapezoidAlt": {
+            const inset = node.width * 0.15;
+            const points = [
+              `${x3},${y2}`,
+              // top-left (full width)
+              `${x3 + node.width},${y2}`,
+              // top-right
+              `${x3 + node.width - inset},${y2 + node.height}`,
+              // bottom-right (narrow)
+              `${x3 + inset},${y2 + node.height}`
+              // bottom-left (narrow)
+            ].join(" ");
+            shape = `<polygon class="node-shape" ${styleAttr} points="${points}" />`;
+            break;
+          }
+          case "cylinder": {
+            const rx = Math.max(8, node.width / 2);
+            const ry = Math.max(6, Math.min(node.height * 0.22, node.width * 0.25));
+            const topCY = y2 + ry;
+            const botCY = y2 + node.height - ry;
+            const bodyH = Math.max(0, node.height - ry * 2);
+            const strokeOnly = this.buildNodeStrokeStyle({ stroke, strokeWidth });
+            shape = `<g>
+          <rect class="node-shape" ${styleAttr} x="${x3}" y="${topCY}" width="${node.width}" height="${bodyH}" />
+          <ellipse class="node-shape" ${styleAttr} cx="${cx}" cy="${topCY}" rx="${node.width / 2}" ry="${ry}" />
+          <path class="node-shape" ${strokeOnly} d="M${x3},${topCY} L${x3},${botCY} A${node.width / 2},${ry} 0 0,0 ${x3 + node.width},${botCY} L${x3 + node.width},${topCY}" fill="none" />
+        </g>`;
+            labelCenterY = topCY + bodyH / 2;
+            break;
+          }
+          case "subroutine":
+            const insetX = 5;
+            const strokeOnly2 = this.buildNodeStrokeStyle({ stroke, strokeWidth });
+            shape = `<g>
+          <rect class="node-shape" ${styleAttr} x="${x3}" y="${y2}" width="${node.width}" height="${node.height}" rx="0" ry="0" />
+          <line class="node-shape" ${strokeOnly2} x1="${x3 + insetX}" y1="${y2}" x2="${x3 + insetX}" y2="${y2 + node.height}" />
+          <line class="node-shape" ${strokeOnly2} x1="${x3 + node.width - insetX}" y1="${y2}" x2="${x3 + node.width - insetX}" y2="${y2 + node.height}" />
+        </g>`;
+            break;
+          case "double":
+            const gap = 4;
+            const strokeOnly3 = this.buildNodeStrokeStyle({ stroke, strokeWidth });
+            shape = `<g>
+          <rect class="node-shape" ${styleAttr} x="${x3}" y="${y2}" width="${node.width}" height="${node.height}" rx="0" ry="0" />
+          <rect class="node-shape" ${strokeOnly3} x="${x3 + gap}" y="${y2 + gap}" width="${node.width - gap * 2}" height="${node.height - gap * 2}" rx="0" ry="0" fill="none" />
+        </g>`;
+            break;
+          default:
+            const s3 = this.buildNodeStyleAttrs({ stroke, strokeWidth, fill });
+            shape = `<rect ${s3} x="${x3}" y="${y2}" width="${node.width}" height="${node.height}" rx="0" ry="0" />`;
+        }
+        const text = this.generateWrappedText(node.label, cx, labelCenterY, node.width - 20);
+        return `<g id="${node.id}">
+    ${shape}
+    ${text}
+  </g>`;
+      }
+      generateWrappedText(text, x3, y2, maxWidth) {
+        if (text.includes("<")) {
+          return this.generateRichText(text, x3, y2, maxWidth);
+        }
+        const charWidth = 7;
+        const maxCharsPerLine = Math.floor(maxWidth / charWidth);
+        if (maxCharsPerLine <= 0 || text.length <= maxCharsPerLine) {
+          const dyOffset = this.fontSize * 0.35;
+          return `<text class="node-label" x="${x3}" y="${y2 + dyOffset}" text-anchor="middle">${this.escapeXml(text)}</text>`;
+        }
+        const words = text.split(" ");
+        const lines = [];
+        let currentLine = "";
+        for (const word of words) {
+          const testLine = currentLine ? `${currentLine} ${word}` : word;
+          if (testLine.length > maxCharsPerLine && currentLine) {
+            lines.push(currentLine);
+            currentLine = word;
+          } else {
+            currentLine = testLine;
+          }
+        }
+        if (currentLine) {
+          lines.push(currentLine);
+        }
+        const lineHeight = 18;
+        const totalHeight = (lines.length - 1) * lineHeight;
+        const startY = y2 - totalHeight / 2 + this.fontSize * 0.35;
+        const tspans = lines.map((line, i3) => {
+          const lineY = startY + i3 * lineHeight;
+          return `<tspan x="${x3}" y="${lineY}" text-anchor="middle">${this.escapeXml(line)}</tspan>`;
+        }).join("\n    ");
+        return `<text class="node-label">
+    ${tspans}
+  </text>`;
+      }
+      // Basic HTML-aware text renderer supporting <br>, <b>/<strong>, <i>/<em>, <u>
+      generateRichText(html, x3, y2, maxWidth) {
+        html = this.normalizeHtml(html);
+        const segments = [];
+        const re = /<\/?(br|b|strong|i|em|u)\s*\/?\s*>/gi;
+        let lastIndex = 0;
+        const state2 = { bold: false, italic: false, underline: false };
+        const pushText = (t3) => {
+          if (!t3)
+            return;
+          segments.push({ text: this.htmlDecode(t3), bold: state2.bold, italic: state2.italic, underline: state2.underline });
+        };
+        let m3;
+        while (m3 = re.exec(html)) {
+          pushText(html.slice(lastIndex, m3.index));
+          const tag2 = m3[0].toLowerCase();
+          const name14 = m3[1].toLowerCase();
+          const isClose = tag2.startsWith("</");
+          if (name14 === "br") {
+            segments.push({ text: "", br: true });
+          } else if (name14 === "b" || name14 === "strong") {
+            state2.bold = !isClose ? true : false;
+          } else if (name14 === "i" || name14 === "em") {
+            state2.italic = !isClose ? true : false;
+          } else if (name14 === "u") {
+            state2.underline = !isClose ? true : false;
+          }
+          lastIndex = re.lastIndex;
+        }
+        pushText(html.slice(lastIndex));
+        const lines = [];
+        const charWidth = 7;
+        const maxCharsPerLine = Math.max(1, Math.floor(maxWidth / charWidth));
+        let current = [];
+        let currentLen = 0;
+        const flush = () => {
+          if (current.length) {
+            lines.push(current);
+            current = [];
+            currentLen = 0;
+          }
+        };
+        const splitWords = (s3) => {
+          if (!s3.text)
+            return [s3];
+          const words = s3.text.split(/(\s+)/);
+          return words.map((w3) => ({ ...s3, text: w3 }));
+        };
+        for (const seg of segments) {
+          if (seg.br) {
+            flush();
+            continue;
+          }
+          for (const w3 of splitWords(seg)) {
+            const wlen = w3.text.length;
+            if (currentLen + wlen > maxCharsPerLine && currentLen > 0) {
+              flush();
+            }
+            current.push(w3);
+            currentLen += wlen;
+          }
+        }
+        flush();
+        const lineHeight = 18;
+        const totalHeight = (lines.length - 1) * lineHeight;
+        const startY = y2 - totalHeight / 2 + this.fontSize * 0.35;
+        const tspans = [];
+        for (let i3 = 0; i3 < lines.length; i3++) {
+          const lineY = startY + i3 * lineHeight;
+          let acc = "";
+          let cursorX = x3;
+          const inner = [];
+          let buffer = "";
+          let style = { bold: false, italic: false, underline: false };
+          const flushInline = () => {
+            if (!buffer)
+              return;
+            const styleAttr = `${style.bold ? 'font-weight="bold" ' : ""}${style.italic ? 'font-style="italic" ' : ""}${style.underline ? 'text-decoration="underline" ' : ""}`;
+            inner.push(`<tspan ${styleAttr}>${this.escapeXml(buffer)}</tspan>`);
+            buffer = "";
+          };
+          for (const w3 of lines[i3]) {
+            const wStyle = { bold: !!w3.bold, italic: !!w3.italic, underline: !!w3.underline };
+            if (wStyle.bold !== style.bold || wStyle.italic !== style.italic || wStyle.underline !== style.underline) {
+              flushInline();
+              style = wStyle;
+            }
+            buffer += w3.text;
+          }
+          flushInline();
+          tspans.push(`<tspan x="${x3}" y="${lineY}" text-anchor="middle">${inner.join("")}</tspan>`);
+        }
+        return `<text font-family="${this.fontFamily}" font-size="${this.fontSize}" fill="#333">${tspans.join("\n    ")}</text>`;
+      }
+      normalizeHtml(s3) {
+        let out = s3.replace(/<\s+/g, "<").replace(/\s+>/g, ">").replace(/<\s*\//g, "</").replace(/\s*\/\s*>/g, "/>").replace(/<\s*(br)\s*>/gi, "<$1/>");
+        return out;
+      }
+      htmlDecode(s3) {
+        return s3.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+      }
+      generateEdge(edge, padX, padY, nodeMap) {
+        if (!edge.points || edge.points.length < 2) {
+          return { path: "" };
+        }
+        const points = edge.points.map((p3) => ({ x: p3.x + padX, y: p3.y + padY }));
+        const segData = this.buildSmoothSegments(points);
+        let strokeDasharray = "";
+        let strokeWidth = 1.5;
+        let markerEnd = "";
+        let markerStart = "";
+        switch (edge.type) {
+          case "open":
+            markerEnd = "";
+            break;
+          case "dotted":
+            strokeDasharray = "3,3";
+            break;
+          case "thick":
+            strokeWidth = 3;
+            break;
+          case "invisible":
+            strokeDasharray = "0,100000";
+            markerEnd = "";
+            break;
+        }
+        const mStart = edge.markerStart;
+        const mEnd = edge.markerEnd;
+        const sourceNode = nodeMap[edge.source];
+        const targetNode = nodeMap[edge.target];
+        let boundaryStart = points[0];
+        let boundaryEnd = points[points.length - 1];
+        if (sourceNode && points.length >= 2) {
+          const pseudo = { start: points[0], segs: [{ c1: points[1], c2: points[Math.max(0, points.length - 2)], to: points[points.length - 1] }] };
+          boundaryStart = this.intersectSegmentsStart(pseudo, sourceNode).start;
+        }
+        if (targetNode && points.length >= 2) {
+          const pseudo = { start: points[0], segs: [{ c1: points[1], c2: points[Math.max(0, points.length - 2)], to: points[points.length - 1] }] };
+          const after = this.intersectSegmentsEnd(pseudo, targetNode);
+          boundaryEnd = after.segs.length ? after.segs[after.segs.length - 1].to : boundaryEnd;
+        }
+        const pathParts = [];
+        pathParts.push(`M${boundaryStart.x},${boundaryStart.y}`);
+        let startFlat = points.length >= 2 ? points[1] : boundaryStart;
+        if (points.length >= 2) {
+          const svx = points[1].x - boundaryStart.x;
+          const svy = points[1].y - boundaryStart.y;
+          const slen = Math.hypot(svx, svy) || 1;
+          const SFLAT = Math.min(22, Math.max(10, slen * 0.15));
+          startFlat = { x: boundaryStart.x + svx / slen * SFLAT, y: boundaryStart.y + svy / slen * SFLAT };
+          pathParts.push(`L${startFlat.x},${startFlat.y}`);
+        }
+        const orthogonal = edge.pathMode === "orthogonal";
+        if (points.length >= 4 && !orthogonal) {
+          const pts = [points[0], ...points, points[points.length - 1]];
+          for (let i3 = 1; i3 < pts.length - 3; i3++) {
+            const p0 = pts[i3 - 1];
+            const p1 = pts[i3];
+            const p22 = pts[i3 + 1];
+            const p3 = pts[i3 + 2];
+            const c1x = p1.x + (p22.x - p0.x) / 6;
+            const c1y = p1.y + (p22.y - p0.y) / 6;
+            const c2x = p22.x - (p3.x - p1.x) / 6;
+            const c2y = p22.y - (p3.y - p1.y) / 6;
+            pathParts.push(`C${c1x},${c1y} ${c2x},${c2y} ${p22.x},${p22.y}`);
+          }
+          pathParts.push(`L${boundaryEnd.x},${boundaryEnd.y}`);
+        } else if (points.length === 3 && !orthogonal) {
+          const p0 = boundaryStart, p1 = points[1], p22 = boundaryEnd;
+          const ax = boundaryEnd.x - p1.x;
+          const ay = boundaryEnd.y - p1.y;
+          const alen = Math.hypot(ax, ay) || 1;
+          const FLAT_IN = Math.min(20, Math.max(10, alen * 0.15));
+          const preEnd = { x: boundaryEnd.x - ax / alen * FLAT_IN, y: boundaryEnd.y - ay / alen * FLAT_IN };
+          const sdx = startFlat.x - boundaryStart.x;
+          const sdy = startFlat.y - boundaryStart.y;
+          const sdirx = sdx === 0 && sdy === 0 ? p1.x - p0.x : sdx;
+          const sdiry = sdx === 0 && sdy === 0 ? p1.y - p0.y : sdy;
+          const sdlen = Math.hypot(sdirx, sdiry) || 1;
+          const c1len = Math.min(40, Math.max(12, sdlen * 1.2));
+          const c1x = startFlat.x + sdirx / sdlen * c1len;
+          const c1y = startFlat.y + sdiry / sdlen * c1len;
+          const dirx = (boundaryEnd.x - p1.x) / alen;
+          const diry = (boundaryEnd.y - p1.y) / alen;
+          const c2x = preEnd.x - dirx * (FLAT_IN * 0.6);
+          const c2y = preEnd.y - diry * (FLAT_IN * 0.6);
+          pathParts.push(`C${c1x},${c1y} ${c2x},${c2y} ${preEnd.x},${preEnd.y}`);
+          pathParts.push(`L${boundaryEnd.x},${boundaryEnd.y}`);
+        } else {
+          pathParts.push(`L${boundaryEnd.x},${boundaryEnd.y}`);
+        }
+        if (orthogonal) {
+          pathParts.length = 0;
+          pathParts.push(`M${boundaryStart.x},${boundaryStart.y}`);
+          for (const p3 of points.slice(1, -1))
+            pathParts.push(`L${p3.x},${p3.y}`);
+          pathParts.push(`L${boundaryEnd.x},${boundaryEnd.y}`);
+        }
+        const pathData = pathParts.join(" ");
+        let edgeElement = `<path class="edge-path" d="${pathData}" stroke-linecap="round" stroke-linejoin="round"`;
+        if (strokeDasharray) {
+          edgeElement += ` stroke-dasharray="${strokeDasharray}"`;
+        }
+        const startMarkUrl = mStart === "arrow" ? "url(#arrow)" : mStart === "circle" ? "url(#circle-marker)" : mStart === "cross" ? "url(#cross-marker)" : "";
+        const endMarkUrl = mEnd === "arrow" ? "url(#arrow)" : mEnd === "circle" ? "url(#circle-marker)" : mEnd === "cross" ? "url(#cross-marker)" : markerEnd || "";
+        if (startMarkUrl && mStart !== "arrow")
+          edgeElement += ` marker-start="${startMarkUrl}"`;
+        if (endMarkUrl && mEnd !== "arrow")
+          edgeElement += ` marker-end="${endMarkUrl}"`;
+        edgeElement += " />";
+        if (edge.label) {
+          const pos = this.pointAtRatio(points, 0.55);
+          const text = this.escapeXml(edge.label);
+          const padding = 4;
+          const fontSize = this.fontSize - 3;
+          const width = Math.max(18, Math.min(220, text.length * 6 + padding * 2));
+          const height = 14;
+          const x3 = pos.x - width / 2;
+          const y2 = pos.y - height / 2;
+          const labelBg = `<rect class="edge-label-bg" x="${x3}" y="${y2}" width="${width}" height="${height}" rx="3" />`;
+          const labelText = `<text class="edge-label-text" x="${pos.x}" y="${pos.y}" text-anchor="middle" dominant-baseline="middle">${text}</text>`;
+          let overlay2 = "";
+          const prevEndL = points.length >= 2 ? points[points.length - 2] : boundaryEnd;
+          const vxl = boundaryEnd.x - prevEndL.x;
+          const vyl = boundaryEnd.y - prevEndL.y;
+          const vlenl = Math.hypot(vxl, vyl) || 1;
+          const uxl = vxl / vlenl;
+          const uyl = vyl / vlenl;
+          const nxl = -uyl;
+          const nyl = uxl;
+          const triLenL = 8;
+          const triWL = 6;
+          const p1xL = boundaryEnd.x, p1yL = boundaryEnd.y;
+          const baseXL = boundaryEnd.x - uxl * triLenL;
+          const baseYL = boundaryEnd.y - uyl * triLenL;
+          const p2xL = baseXL + nxl * (triWL / 2), p2yL = baseYL + nyl * (triWL / 2);
+          const p3xL = baseXL - nxl * (triWL / 2), p3yL = baseYL - nyl * (triWL / 2);
+          overlay2 += triangleAtEnd(prevEndL, boundaryEnd, this.arrowStroke);
+          if (mStart === "arrow" && points.length >= 2) {
+            const firstLeg = points[1];
+            const svx = boundaryStart.x - firstLeg.x;
+            const svy = boundaryStart.y - firstLeg.y;
+            const slen = Math.hypot(svx, svy) || 1;
+            const sux = svx / slen;
+            const suy = svy / slen;
+            const snx = -suy;
+            const sny = sux;
+            const sbaseX = boundaryStart.x - sux * triLenL;
+            const sbaseY = boundaryStart.y - suy * triLenL;
+            overlay2 += triangleAtStart(boundaryStart, firstLeg, this.arrowStroke);
+          }
+          const pathGroup = `<g>
+    ${edgeElement}
+    ${labelBg}
+    ${labelText}
+    ${overlay2}
+  </g>`;
+          return { path: pathGroup };
+        }
+        let overlay = "";
+        const prevEnd = points.length >= 2 ? points[points.length - 2] : boundaryEnd;
+        const vx = boundaryEnd.x - prevEnd.x;
+        const vy = boundaryEnd.y - prevEnd.y;
+        const vlen = Math.hypot(vx, vy) || 1;
+        const ux = vx / vlen;
+        const uy = vy / vlen;
+        const nx = -uy;
+        const ny = ux;
+        const triLen = 8;
+        const triW = 6;
+        const p1x = boundaryEnd.x, p1y = boundaryEnd.y;
+        const baseX = boundaryEnd.x - ux * triLen;
+        const baseY = boundaryEnd.y - uy * triLen;
+        const p2x = baseX + nx * (triW / 2), p2y = baseY + ny * (triW / 2);
+        const p3x = baseX - nx * (triW / 2), p3y = baseY - ny * (triW / 2);
+        if (mEnd === "arrow")
+          overlay += triangleAtEnd(prevEnd, boundaryEnd, this.arrowStroke);
+        if (mStart === "arrow" && points.length >= 2) {
+          const firstLeg = points[1];
+          const svx = boundaryStart.x - firstLeg.x;
+          const svy = boundaryStart.y - firstLeg.y;
+          const slen = Math.hypot(svx, svy) || 1;
+          const sux = svx / slen;
+          const suy = svy / slen;
+          const snx = -suy;
+          const sny = sux;
+          overlay += triangleAtStart(boundaryStart, firstLeg, this.arrowStroke);
+        }
+        if (overlay) {
+          const grouped = `<g>${edgeElement}
+${overlay}</g>`;
+          return { path: grouped };
+        }
+        return { path: edgeElement };
+      }
+      // --- helpers ---
+      buildSmoothSegments(points) {
+        if (points.length < 2) {
+          const p3 = points[0] || { x: 0, y: 0 };
+          return { start: p3, segs: [] };
+        }
+        if (points.length === 2) {
+          const p0 = points[0];
+          const p1 = points[1];
+          const c1 = { x: p0.x + (p1.x - p0.x) / 3, y: p0.y + (p1.y - p0.y) / 3 };
+          const c22 = { x: p0.x + 2 * (p1.x - p0.x) / 3, y: p0.y + 2 * (p1.y - p0.y) / 3 };
+          return { start: p0, segs: [{ c1, c2: c22, to: p1 }] };
+        }
+        const pts = [points[0], ...points, points[points.length - 1]];
+        const segs = [];
+        const firstIdx = 1;
+        const lastIdx = pts.length - 3;
+        const midFactor = 1;
+        const endFactor = 0.35;
+        const FLAT_LEN = 28;
+        for (let i3 = 1; i3 < pts.length - 2; i3++) {
+          const p0 = pts[i3 - 1];
+          const p1 = pts[i3];
+          const p22 = pts[i3 + 1];
+          const p3 = pts[i3 + 2];
+          const f1 = i3 === firstIdx ? endFactor : midFactor;
+          const f22 = i3 === lastIdx ? endFactor : midFactor;
+          let c1 = { x: p1.x + (p22.x - p0.x) / 6 * f1, y: p1.y + (p22.y - p0.y) / 6 * f1 };
+          let c22 = { x: p22.x - (p3.x - p1.x) / 6 * f22, y: p22.y - (p3.y - p1.y) / 6 * f22 };
+          if (i3 === firstIdx) {
+            const dx = p22.x - p1.x, dy = p22.y - p1.y;
+            const len = Math.hypot(dx, dy) || 1;
+            const t3 = Math.min(FLAT_LEN, len * 0.5);
+            c1 = { x: p1.x + dx / len * t3, y: p1.y + dy / len * t3 };
+          }
+          if (i3 === lastIdx) {
+            const dx = p22.x - p1.x, dy = p22.y - p1.y;
+            const len = Math.hypot(dx, dy) || 1;
+            const t3 = Math.min(FLAT_LEN, len * 0.5);
+            c22 = { x: p22.x - dx / len * t3, y: p22.y - dy / len * t3 };
+          }
+          segs.push({ c1, c2: c22, to: { x: p22.x, y: p22.y } });
+        }
+        return { start: pts[1], segs };
+      }
+      pathFromSegments(data2) {
+        let d3 = `M${data2.start.x},${data2.start.y}`;
+        for (const s3 of data2.segs) {
+          d3 += ` C${s3.c1.x},${s3.c1.y} ${s3.c2.x},${s3.c2.y} ${s3.to.x},${s3.to.y}`;
+        }
+        return d3;
+      }
+      trimSegmentsEnd(data2, cut) {
+        const segs = data2.segs.slice();
+        if (!segs.length)
+          return data2;
+        const last2 = { ...segs[segs.length - 1] };
+        const vx = last2.to.x - last2.c2.x;
+        const vy = last2.to.y - last2.c2.y;
+        const len = Math.hypot(vx, vy) || 1;
+        const eff = Math.max(0.1, Math.min(cut, Math.max(0, len - 0.2)));
+        const nx = vx / len;
+        const ny = vy / len;
+        const newTo = { x: last2.to.x - nx * eff, y: last2.to.y - ny * eff };
+        last2.to = newTo;
+        segs[segs.length - 1] = last2;
+        return { start: data2.start, segs };
+      }
+      trimSegmentsStart(data2, cut) {
+        const segs = data2.segs.slice();
+        if (!segs.length)
+          return data2;
+        const first2 = { ...segs[0] };
+        const vx = first2.c1.x - data2.start.x;
+        const vy = first2.c1.y - data2.start.y;
+        const len = Math.hypot(vx, vy) || 1;
+        const eff = Math.max(0.1, Math.min(cut, Math.max(0, len - 0.2)));
+        const nx = vx / len;
+        const ny = vy / len;
+        const newStart = { x: data2.start.x + nx * eff, y: data2.start.y + ny * eff };
+        return { start: newStart, segs };
+      }
+      // ---- shape intersections ----
+      intersectSegmentsEnd(data2, node) {
+        if (!data2.segs.length)
+          return data2;
+        const last2 = data2.segs[data2.segs.length - 1];
+        const p1 = last2.c2;
+        const p22 = last2.to;
+        const hit = this.intersectLineWithNode(p1, p22, node);
+        if (hit) {
+          const segs = data2.segs.slice();
+          segs[segs.length - 1] = { ...last2, to: hit };
+          return { start: data2.start, segs };
+        }
+        return data2;
+      }
+      intersectSegmentsStart(data2, node) {
+        if (!data2.segs.length)
+          return data2;
+        const first2 = data2.segs[0];
+        const p1 = data2.start;
+        const p22 = first2.c1;
+        const hit = this.intersectLineWithNode(p1, p22, node);
+        if (hit) {
+          return { start: hit, segs: data2.segs };
+        }
+        return data2;
+      }
+      intersectLineWithNode(p1, p22, node) {
+        const shape = node.shape;
+        const rectPoly = () => [
+          { x: node.x, y: node.y },
+          { x: node.x + node.width, y: node.y },
+          { x: node.x + node.width, y: node.y + node.height },
+          { x: node.x, y: node.y + node.height }
+        ];
+        switch (shape) {
+          case "circle": {
+            const cx = node.x + node.width / 2;
+            const cy = node.y + node.height / 2;
+            const r3 = Math.min(node.width, node.height) / 2;
+            return this.lineCircleIntersection(p1, p22, { cx, cy, r: r3 });
+          }
+          case "diamond": {
+            const cx = node.x + node.width / 2;
+            const cy = node.y + node.height / 2;
+            const poly = [{ x: cx, y: node.y }, { x: node.x + node.width, y: cy }, { x: cx, y: node.y + node.height }, { x: node.x, y: cy }];
+            return this.linePolygonIntersection(p1, p22, poly);
+          }
+          case "hexagon": {
+            const s3 = Math.max(10, node.width * 0.2);
+            const poly = [
+              { x: node.x + s3, y: node.y },
+              { x: node.x + node.width - s3, y: node.y },
+              { x: node.x + node.width, y: node.y + node.height / 2 },
+              { x: node.x + node.width - s3, y: node.y + node.height },
+              { x: node.x + s3, y: node.y + node.height },
+              { x: node.x, y: node.y + node.height / 2 }
+            ];
+            return this.linePolygonIntersection(p1, p22, poly);
+          }
+          case "parallelogram": {
+            const o3 = Math.min(node.width * 0.25, node.height * 0.6);
+            const poly = [
+              { x: node.x + o3, y: node.y },
+              { x: node.x + node.width, y: node.y },
+              { x: node.x + node.width - o3, y: node.y + node.height },
+              { x: node.x, y: node.y + node.height }
+            ];
+            return this.linePolygonIntersection(p1, p22, poly);
+          }
+          case "trapezoid": {
+            const o3 = Math.min(node.width * 0.2, node.height * 0.5);
+            const poly = [
+              { x: node.x + o3, y: node.y },
+              { x: node.x + node.width - o3, y: node.y },
+              { x: node.x + node.width, y: node.y + node.height },
+              { x: node.x, y: node.y + node.height }
+            ];
+            return this.linePolygonIntersection(p1, p22, poly);
+          }
+          case "trapezoidAlt": {
+            const o3 = Math.min(node.width * 0.2, node.height * 0.5);
+            const poly = [
+              { x: node.x, y: node.y },
+              { x: node.x + node.width, y: node.y },
+              { x: node.x + node.width - o3, y: node.y + node.height },
+              { x: node.x + o3, y: node.y + node.height }
+            ];
+            return this.linePolygonIntersection(p1, p22, poly);
+          }
+          case "stadium": {
+            const r3 = Math.min(node.height / 2, node.width / 2);
+            const rect = [
+              { x: node.x + r3, y: node.y },
+              { x: node.x + node.width - r3, y: node.y },
+              { x: node.x + node.width - r3, y: node.y + node.height },
+              { x: node.x + r3, y: node.y + node.height }
+            ];
+            const hitRect = this.linePolygonIntersection(p1, p22, rect);
+            if (hitRect)
+              return hitRect;
+            const left = this.lineCircleIntersection(p1, p22, { cx: node.x + r3, cy: node.y + node.height / 2, r: r3 });
+            const right = this.lineCircleIntersection(p1, p22, { cx: node.x + node.width - r3, cy: node.y + node.height / 2, r: r3 });
+            const pick = (...pts) => {
+              let best = null;
+              let bestd = -Infinity;
+              for (const pt of pts)
+                if (pt) {
+                  const d3 = -((pt.x - p22.x) ** 2 + (pt.y - p22.y) ** 2);
+                  if (d3 > bestd) {
+                    bestd = d3;
+                    best = pt;
+                  }
+                }
+              return best;
+            };
+            return pick(left, right);
+          }
+          default: {
+            return this.linePolygonIntersection(p1, p22, rectPoly());
+          }
+        }
+      }
+      lineCircleIntersection(p1, p22, c3) {
+        const dx = p22.x - p1.x;
+        const dy = p22.y - p1.y;
+        const fx = p1.x - c3.cx;
+        const fy = p1.y - c3.cy;
+        const a3 = dx * dx + dy * dy;
+        const b3 = 2 * (fx * dx + fy * dy);
+        const cc2 = fx * fx + fy * fy - c3.r * c3.r;
+        const disc = b3 * b3 - 4 * a3 * cc2;
+        if (disc < 0)
+          return null;
+        const s3 = Math.sqrt(disc);
+        const t1 = (-b3 - s3) / (2 * a3);
+        const t22 = (-b3 + s3) / (2 * a3);
+        const ts = [t1, t22].filter((t4) => t4 >= 0 && t4 <= 1);
+        if (!ts.length)
+          return null;
+        const t3 = Math.max(...ts);
+        return { x: p1.x + dx * t3, y: p1.y + dy * t3 };
+      }
+      linePolygonIntersection(p1, p22, poly) {
+        let bestT = -Infinity;
+        let best = null;
+        for (let i3 = 0; i3 < poly.length; i3++) {
+          const a3 = poly[i3];
+          const b3 = poly[(i3 + 1) % poly.length];
+          const hit = this.segmentIntersection(p1, p22, a3, b3);
+          if (hit && hit.t >= 0 && hit.t <= 1 && hit.u >= 0 && hit.u <= 1) {
+            if (hit.t > bestT) {
+              bestT = hit.t;
+              best = { x: hit.x, y: hit.y };
+            }
+          }
+        }
+        return best;
+      }
+      segmentIntersection(p3, p22, q3, q22) {
+        const r3 = { x: p22.x - p3.x, y: p22.y - p3.y };
+        const s3 = { x: q22.x - q3.x, y: q22.y - q3.y };
+        const rxs = r3.x * s3.y - r3.y * s3.x;
+        if (Math.abs(rxs) < 1e-6)
+          return null;
+        const q_p = { x: q3.x - p3.x, y: q3.y - p3.y };
+        const t3 = (q_p.x * s3.y - q_p.y * s3.x) / rxs;
+        const u3 = (q_p.x * r3.y - q_p.y * r3.x) / rxs;
+        const x3 = p3.x + t3 * r3.x;
+        const y2 = p3.y + t3 * r3.y;
+        return { x: x3, y: y2, t: t3, u: u3 };
+      }
+      pointAtRatio(points, ratio) {
+        const clampRatio = Math.max(0, Math.min(1, ratio));
+        let total = 0;
+        const segs = [];
+        for (let i3 = 0; i3 < points.length - 1; i3++) {
+          const dx = points[i3 + 1].x - points[i3].x;
+          const dy = points[i3 + 1].y - points[i3].y;
+          const len = Math.hypot(dx, dy);
+          segs.push(len);
+          total += len;
+        }
+        if (total === 0)
+          return points[Math.floor(points.length / 2)];
+        let target = total * clampRatio;
+        for (let i3 = 0; i3 < segs.length; i3++) {
+          if (target <= segs[i3]) {
+            const t3 = segs[i3] === 0 ? 0 : target / segs[i3];
+            return {
+              x: points[i3].x + (points[i3 + 1].x - points[i3].x) * t3,
+              y: points[i3].y + (points[i3 + 1].y - points[i3].y) * t3
+            };
+          }
+          target -= segs[i3];
+        }
+        return points[points.length - 1];
+      }
+      escapeXml(text) {
+        return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+      }
+    };
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/pie-builder.js
+function unquote(s3) {
+  if (!s3)
+    return s3;
+  const first2 = s3.charAt(0);
+  const last2 = s3.charAt(s3.length - 1);
+  if (first2 === '"' && last2 === '"' || first2 === "'" && last2 === "'") {
+    const inner = s3.slice(1, -1);
+    return inner.replace(/\\(["'])/g, "$1");
+  }
+  return s3;
+}
+function buildPieModel(text) {
+  const errors = [];
+  const lex = tokenize2(text);
+  for (const e3 of lex.errors) {
+    errors.push({
+      line: e3.line ?? 1,
+      column: e3.column ?? 1,
+      message: e3.message,
+      code: "PIE_LEX",
+      severity: "error"
+    });
+  }
+  parserInstance2.reset();
+  parserInstance2.input = lex.tokens;
+  const cst = parserInstance2.diagram();
+  for (const e3 of parserInstance2.errors) {
+    const t3 = e3.token;
+    errors.push({
+      line: t3?.startLine ?? 1,
+      column: t3?.startColumn ?? 1,
+      message: e3.message,
+      code: "PIE_PARSE",
+      severity: "error"
+    });
+  }
+  const model = { title: void 0, showData: false, slices: [] };
+  if (!cst || !cst.children)
+    return { model, errors };
+  if (cst.children.ShowDataKeyword && cst.children.ShowDataKeyword.length > 0) {
+    model.showData = true;
+  }
+  const statements = cst.children.statement ?? [];
+  for (const st of statements) {
+    if (st.children?.titleStmt) {
+      const tnode = st.children.titleStmt[0];
+      const parts = [];
+      const collect = (k3) => {
+        const arr = tnode.children?.[k3] ?? [];
+        for (const tok of arr)
+          parts.push(unquote(tok.image));
+      };
+      collect("QuotedString");
+      collect("Text");
+      collect("NumberLiteral");
+      const title = parts.join(" ").trim();
+      if (title)
+        model.title = title;
+    } else if (st.children?.sliceStmt) {
+      const snode = st.children.sliceStmt[0];
+      const labelTok = snode.children?.sliceLabel?.[0]?.children?.QuotedString?.[0];
+      const numTok = snode.children?.NumberLiteral?.[0];
+      if (labelTok && numTok) {
+        const label = unquote(labelTok.image).trim();
+        const value = Number(numTok.image);
+        if (!Number.isNaN(value)) {
+          model.slices.push({ label, value });
+        }
+      }
+    }
+  }
+  return { model, errors };
+}
+var init_pie_builder = __esm({
+  "node_modules/@probelabs/maid/out/renderer/pie-builder.js"() {
+    init_lexer3();
+    init_parser3();
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/pie-renderer.js
+function polarToCartesian(cx, cy, r3, angleRad) {
+  return { x: cx + r3 * Math.cos(angleRad), y: cy + r3 * Math.sin(angleRad) };
+}
+function renderPie(model, opts = {}) {
+  let width = Math.max(320, Math.floor(opts.width ?? 640));
+  const height = Math.max(240, Math.floor(opts.height ?? 400));
+  const pad = 24;
+  const titleH = model.title ? 28 : 0;
+  let cx = width / 2;
+  const cy = (height + titleH) / 2 + (model.title ? 8 : 0);
+  const baseRadius = Math.max(40, Math.min(width, height - titleH) / 2 - pad);
+  const slices = model.slices.filter((s3) => Math.max(0, s3.value) > 0);
+  const total = slices.reduce((a3, s3) => a3 + Math.max(0, s3.value), 0);
+  const LEG_SW = 12;
+  const LEG_GAP = 8;
+  const LEG_VSPACE = 18;
+  const legendItems = slices.map((s3) => `${s3.label}${model.showData ? ` ${formatNumber(Number(s3.value))}` : ""}`);
+  const legendTextWidth = legendItems.length ? Math.max(...legendItems.map((t3) => measureText(t3, 12))) : 0;
+  const legendBlockWidth = legendItems.length ? LEG_SW + LEG_GAP + legendTextWidth + pad : 0;
+  if (legendItems.length) {
+    const neededWidth = pad + baseRadius * 2 + legendBlockWidth + pad;
+    if (neededWidth > width)
+      width = Math.ceil(neededWidth);
+  }
+  let radius = baseRadius;
+  if (legendItems.length) {
+    const leftPad = Math.max(pad, (width - legendBlockWidth - radius * 2) / 2);
+    cx = leftPad + radius;
+  }
+  let start = -Math.PI / 2;
+  let svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">`;
+  svg += `
+  <style>
+    .pie-title { font-family: Arial, sans-serif; font-size: 16px; font-weight: 600; fill: #222; }
+    .slice-label { font-family: Arial, sans-serif; font-size: 12px; fill: #222; dominant-baseline: middle; }
+    .leader { stroke: #444; stroke-width: 1; fill: none; }
+    .pieCircle { stroke: black; stroke-width: 2px; opacity: 0.7; }
+    .pieOuterCircle { stroke: black; stroke-width: 2px; fill: none; }
+  </style>`;
+  if (model.title) {
+    svg += `
+  <text class="pie-title" x="${cx}" y="${pad + 8}" text-anchor="middle">${escapeXml(model.title)}</text>`;
+  }
+  svg += `
+  <g class="pie" aria-label="pie">`;
+  const minOutsideAngle = 0.35;
+  slices.forEach((s3, i3) => {
+    const pct = total > 0 ? Math.max(0, s3.value) / total : 0;
+    const angle = 2 * Math.PI * pct;
+    const end = start + angle;
+    const large = angle > Math.PI ? 1 : 0;
+    const c0 = polarToCartesian(cx, cy, radius, start);
+    const c1 = polarToCartesian(cx, cy, radius, end);
+    const d3 = [
+      `M ${cx} ${cy}`,
+      `L ${c0.x.toFixed(2)} ${c0.y.toFixed(2)}`,
+      `A ${radius} ${radius} 0 ${large} 1 ${c1.x.toFixed(2)} ${c1.y.toFixed(2)}`,
+      "Z"
+    ].join(" ");
+    const fill = s3.color || palette(i3);
+    svg += `
+    <path d="${d3}" class="pieCircle" fill="${fill}" />`;
+    const mid = (start + end) / 2;
+    const cos = Math.cos(mid);
+    const sin = Math.sin(mid);
+    const percentLabel = escapeXml(formatPercent(s3.value, total));
+    if (angle < minOutsideAngle) {
+      const r1 = radius * 0.9;
+      const r22 = radius * 1.06;
+      const p1 = polarToCartesian(cx, cy, r1, mid);
+      const p22 = polarToCartesian(cx, cy, r22, mid);
+      const hlen = 12;
+      const anchorLeft = cos < 0;
+      const hx = anchorLeft ? p22.x - hlen : p22.x + hlen;
+      const hy = p22.y;
+      svg += `
+    <path class="leader" d="M ${p1.x.toFixed(2)} ${p1.y.toFixed(2)} L ${p22.x.toFixed(2)} ${p22.y.toFixed(2)} L ${hx.toFixed(2)} ${hy.toFixed(2)}" />`;
+      const tx = anchorLeft ? hx - 2 : hx + 2;
+      const tAnchor = anchorLeft ? "end" : "start";
+      svg += `
+    <text class="slice-label" x="${tx.toFixed(2)}" y="${hy.toFixed(2)}" text-anchor="${tAnchor}">${percentLabel}</text>`;
+    } else {
+      const lr = radius * 0.62;
+      const lp = { x: cx + lr * cos, y: cy + lr * sin };
+      const tAnchor = Math.abs(cos) < 0.2 ? "middle" : cos > 0 ? "start" : "end";
+      const avail = lr;
+      const textW = measureText(percentLabel, 12);
+      const anchor = textW > avail * 1.2 ? "middle" : tAnchor;
+      svg += `
+    <text class="slice-label" x="${lp.x.toFixed(2)}" y="${lp.y.toFixed(2)}" text-anchor="${anchor}">${percentLabel}</text>`;
+    }
+    start = end;
+  });
+  const rimStroke = opts.rimStroke || "black";
+  const rimWidth = opts.rimStrokeWidth != null ? String(opts.rimStrokeWidth) : "2px";
+  svg += `
+  </g>
+  <circle class="pie-rim pieOuterCircle" cx="${cx}" cy="${cy}" r="${radius}" stroke="${rimStroke}" stroke-width="${rimWidth}" fill="none" />`;
+  if (legendItems.length) {
+    const legendX = cx + radius + pad / 2;
+    const totalH = legendItems.length * LEG_VSPACE;
+    let legendY = cy - totalH / 2 + 10;
+    svg += `
+  <g class="legend">`;
+    slices.forEach((s3, i3) => {
+      const y2 = legendY + i3 * LEG_VSPACE;
+      const fill = s3.color || palette(i3);
+      const text = escapeXml(`${s3.label}${model.showData ? ` ${formatNumber(Number(s3.value))}` : ""}`);
+      svg += `
+    <rect x="${legendX}" y="${y2 - LEG_SW + 6}" width="${LEG_SW}" height="${LEG_SW}" fill="${fill}" stroke="${fill}" stroke-width="1" />`;
+      svg += `
+    <text class="slice-label legend-text" x="${legendX + LEG_SW + LEG_GAP}" y="${y2}" text-anchor="start">${text}</text>`;
+    });
+    svg += `
+  </g>`;
+  }
+  svg += `
+</svg>`;
+  return svg;
+}
+var init_pie_renderer = __esm({
+  "node_modules/@probelabs/maid/out/renderer/pie-renderer.js"() {
+    init_utils4();
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/sequence-builder.js
+function textFromTokens(tokens) {
+  if (!tokens || tokens.length === 0)
+    return "";
+  const parts = [];
+  for (const t3 of tokens) {
+    const img = t3.image;
+    if (!img)
+      continue;
+    if (t3.tokenType && t3.tokenType.name === "QuotedString") {
+      if (img.startsWith('"') && img.endsWith('"'))
+        parts.push(img.slice(1, -1));
+      else if (img.startsWith("'") && img.endsWith("'"))
+        parts.push(img.slice(1, -1));
+      else
+        parts.push(img);
+    } else {
+      parts.push(img);
+    }
+  }
+  return parts.join(" ").replace(/\s+/g, " ").trim();
+}
+function actorRefToText(refCst) {
+  const ch = refCst.children || {};
+  const toks = [];
+  ["Identifier", "QuotedString", "NumberLiteral", "Text"].forEach((k3) => {
+    const a3 = ch[k3];
+    a3?.forEach((t3) => toks.push(t3));
+  });
+  toks.sort((a3, b3) => (a3.startOffset ?? 0) - (b3.startOffset ?? 0));
+  return textFromTokens(toks);
+}
+function lineRemainderToText(lineRem) {
+  if (!lineRem)
+    return void 0;
+  const ch = lineRem.children || {};
+  const toks = [];
+  const order = [
+    "Identifier",
+    "NumberLiteral",
+    "QuotedString",
+    "Text",
+    "Plus",
+    "Minus",
+    "Comma",
+    "Colon",
+    "LParen",
+    "RParen",
+    "AndKeyword",
+    "ElseKeyword",
+    "OptKeyword",
+    "OptionKeyword",
+    "LoopKeyword",
+    "ParKeyword",
+    "RectKeyword",
+    "CriticalKeyword",
+    "BreakKeyword",
+    "BoxKeyword",
+    "EndKeyword",
+    "NoteKeyword",
+    "LeftKeyword",
+    "RightKeyword",
+    "OverKeyword",
+    "OfKeyword",
+    "AutonumberKeyword",
+    "OffKeyword",
+    "LinkKeyword",
+    "LinksKeyword",
+    "CreateKeyword",
+    "DestroyKeyword",
+    "ParticipantKeyword",
+    "ActorKeyword",
+    "ActivateKeyword",
+    "DeactivateKeyword"
+  ];
+  for (const k3 of order)
+    ch[k3]?.forEach((t3) => toks.push(t3));
+  toks.sort((a3, b3) => (a3.startOffset ?? 0) - (b3.startOffset ?? 0));
+  return textFromTokens(toks) || void 0;
+}
+function canonicalId(raw) {
+  const t3 = raw.trim().replace(/\s+/g, "_");
+  return t3;
+}
+function ensureParticipant(map4, byDisplay, idLike, display) {
+  const idGuess = canonicalId(idLike);
+  const existing = map4.get(idGuess) || (byDisplay.get(idLike) ? map4.get(byDisplay.get(idLike)) : void 0);
+  if (existing)
+    return existing;
+  const p3 = { id: idGuess, display: display || idLike };
+  map4.set(p3.id, p3);
+  byDisplay.set(p3.display, p3.id);
+  return p3;
+}
+function msgFromArrow(arrowCst) {
+  const ch = arrowCst.children || {};
+  if (ch.BidirAsyncDotted)
+    return { line: "dotted", start: "arrow", end: "arrow", async: true };
+  if (ch.BidirAsync)
+    return { line: "solid", start: "arrow", end: "arrow", async: true };
+  if (ch.DottedAsync)
+    return { line: "dotted", start: "none", end: "arrow", async: true };
+  if (ch.Async)
+    return { line: "solid", start: "none", end: "arrow", async: true };
+  if (ch.Dotted)
+    return { line: "dotted", start: "none", end: "arrow" };
+  if (ch.Solid)
+    return { line: "solid", start: "none", end: "arrow" };
+  if (ch.DottedCross)
+    return { line: "dotted", start: "none", end: "cross" };
+  if (ch.Cross)
+    return { line: "solid", start: "none", end: "cross" };
+  if (ch.DottedOpen)
+    return { line: "dotted", start: "none", end: "open" };
+  if (ch.Open)
+    return { line: "solid", start: "none", end: "open" };
+  return { line: "solid", start: "none", end: "arrow" };
+}
+function buildSequenceModel(text) {
+  const { tokens } = tokenize3(text);
+  parserInstance3.input = tokens;
+  const cst = parserInstance3.diagram();
+  const participantsMap = /* @__PURE__ */ new Map();
+  const byDisplay = /* @__PURE__ */ new Map();
+  const events = [];
+  let autonumber = { on: false };
+  const diagramChildren = cst.children || {};
+  const lines = diagramChildren.line || [];
+  const openBlocks = [];
+  function processLineNode(ln) {
+    const ch = ln.children || {};
+    if (ch.participantDecl) {
+      const decl = ch.participantDecl[0];
+      const dch = decl.children || {};
+      const ref1 = dch.actorRef?.[0];
+      const ref2 = dch.actorRef?.[1];
+      const idText = actorRefToText(ref1);
+      const aliasText = ref2 ? actorRefToText(ref2) : void 0;
+      const id = canonicalId(idText);
+      const display = aliasText || idText;
+      const p3 = ensureParticipant(participantsMap, byDisplay, id, display);
+      events.push({ kind: "create", actor: p3.id, display: p3.display });
+      return;
+    }
+    if (ch.autonumberStmt) {
+      const stmt = ch.autonumberStmt[0];
+      const sch = stmt.children || {};
+      autonumber = { on: true };
+      const nums = sch.NumberLiteral || [];
+      if (nums.length >= 1)
+        autonumber.start = Number(nums[0].image);
+      if (nums.length >= 2)
+        autonumber.step = Number(nums[1].image);
+      if (sch.OffKeyword)
+        autonumber = { on: false };
+      return;
+    }
+    if (ch.activateStmt) {
+      const st = ch.activateStmt[0];
+      const sch = st.children || {};
+      const idTxt = actorRefToText(sch.actorRef?.[0]);
+      const p3 = ensureParticipant(participantsMap, byDisplay, idTxt);
+      events.push({ kind: "activate", actor: p3.id });
+      return;
+    }
+    if (ch.deactivateStmt) {
+      const st = ch.deactivateStmt[0];
+      const sch = st.children || {};
+      const idTxt = actorRefToText(sch.actorRef?.[0]);
+      const p3 = ensureParticipant(participantsMap, byDisplay, idTxt);
+      events.push({ kind: "deactivate", actor: p3.id });
+      return;
+    }
+    if (ch.createStmt) {
+      const st = ch.createStmt[0];
+      const sch = st.children || {};
+      const idTxt = actorRefToText(sch.actorRef?.[0]);
+      const alias = sch.lineRemainder ? lineRemainderToText(sch.lineRemainder[0]) : void 0;
+      const p3 = ensureParticipant(participantsMap, byDisplay, idTxt, alias || idTxt);
+      events.push({ kind: "create", actor: p3.id, display: p3.display });
+      return;
+    }
+    if (ch.destroyStmt) {
+      const st = ch.destroyStmt[0];
+      const sch = st.children || {};
+      const idTxt = actorRefToText(sch.actorRef?.[0]);
+      const p3 = ensureParticipant(participantsMap, byDisplay, idTxt);
+      events.push({ kind: "destroy", actor: p3.id });
+      return;
+    }
+    if (ch.noteStmt) {
+      const st = ch.noteStmt[0];
+      const sch = st.children || {};
+      const text2 = lineRemainderToText(sch.lineRemainder?.[0]) || "";
+      if (sch.LeftKeyword || sch.RightKeyword) {
+        const pos = sch.LeftKeyword ? "leftOf" : "rightOf";
+        const actorTxt = actorRefToText(sch.actorRef?.[0]);
+        const p3 = ensureParticipant(participantsMap, byDisplay, actorTxt);
+        const note = { pos, actors: [p3.id], text: text2 };
+        events.push({ kind: "note", note });
+      } else if (sch.OverKeyword) {
+        const a1 = actorRefToText(sch.actorRef?.[0]);
+        const a22 = sch.actorRef?.[1] ? actorRefToText(sch.actorRef?.[1]) : void 0;
+        const p1 = ensureParticipant(participantsMap, byDisplay, a1);
+        const ids = [p1.id];
+        if (a22) {
+          const p22 = ensureParticipant(participantsMap, byDisplay, a22);
+          ids.push(p22.id);
+        }
+        events.push({ kind: "note", note: { pos: "over", actors: ids, text: text2 } });
+      }
+      return;
+    }
+    const blockKinds = [
+      { key: "altBlock", type: "alt", branchKeys: [{ key: "ElseKeyword", kind: "else" }] },
+      { key: "optBlock", type: "opt" },
+      { key: "loopBlock", type: "loop" },
+      { key: "parBlock", type: "par", branchKeys: [{ key: "AndKeyword", kind: "and" }] },
+      { key: "criticalBlock", type: "critical", branchKeys: [{ key: "OptionKeyword", kind: "option" }] },
+      { key: "breakBlock", type: "break" },
+      { key: "rectBlock", type: "rect" },
+      { key: "boxBlock", type: "box" }
+    ];
+    let handledBlock = false;
+    for (const spec of blockKinds) {
+      if (ch[spec.key]) {
+        handledBlock = true;
+        const bnode = ch[spec.key][0];
+        const bch = bnode.children || {};
+        const title = lineRemainderToText(bch.lineRemainder?.[0]);
+        const block = { type: spec.type, title, branches: spec.branchKeys ? [] : void 0 };
+        openBlocks.push(block);
+        events.push({ kind: "block-start", block });
+        if (spec.branchKeys) {
+          const newlines = bch.Newline || [];
+          const branchKey = spec.branchKeys[0].key;
+          const branchTokArr = bch[branchKey];
+          const lrArr = bch.lineRemainder;
+          if (branchTokArr && branchTokArr.length) {
+            const lr = (lrArr || []).slice(1);
+            for (let i3 = 0; i3 < branchTokArr.length; i3++) {
+              const title2 = lr[i3] ? lineRemainderToText(lr[i3]) : void 0;
+              const br = { kind: spec.branchKeys[0].kind, title: title2 };
+              block.branches.push(br);
+              events.push({ kind: "block-branch", block, branch: br });
+            }
+          }
+        }
+        events.push({ kind: "block-end", block });
+        openBlocks.pop();
+        break;
+      }
+    }
+    if (handledBlock)
+      return;
+    if (ch.messageStmt) {
+      const st = ch.messageStmt[0];
+      const sch = st.children || {};
+      const fromTxt = actorRefToText(sch.actorRef?.[0]);
+      const toTxt = actorRefToText(sch.actorRef?.[1]);
+      const from = ensureParticipant(participantsMap, byDisplay, fromTxt).id;
+      const to = ensureParticipant(participantsMap, byDisplay, toTxt).id;
+      const arrow = msgFromArrow(sch.arrow?.[0]);
+      const text2 = lineRemainderToText(sch.lineRemainder?.[0]);
+      const activateTarget = !!sch.Plus;
+      const deactivateTarget = !!sch.Minus;
+      const msg = { from, to, text: text2, line: arrow.line, startMarker: arrow.start, endMarker: arrow.end, async: arrow.async, activateTarget, deactivateTarget };
+      events.push({ kind: "message", msg });
+      return;
+    }
+    if (ch.linkStmt) {
+      events.push({ kind: "noop" });
+      return;
+    }
+    events.push({ kind: "noop" });
+  }
+  function collectInnerLines(blockNode) {
+    const out = [];
+    const ch = blockNode.children || {};
+    for (const key of Object.keys(ch)) {
+      const arr = ch[key];
+      if (Array.isArray(arr)) {
+        for (const node of arr) {
+          if (node && typeof node === "object" && node.name === "line")
+            out.push(node);
+        }
+      }
+    }
+    return out;
+  }
+  for (const ln of lines) {
+    processLineNode(ln);
+    const ch = ln.children || {};
+    const block = ch.altBlock?.[0] || ch.optBlock?.[0] || ch.loopBlock?.[0] || ch.parBlock?.[0] || ch.criticalBlock?.[0] || ch.breakBlock?.[0] || ch.rectBlock?.[0] || ch.boxBlock?.[0];
+    if (block) {
+      for (const inner of collectInnerLines(block))
+        processLineNode(inner);
+    }
+  }
+  return {
+    participants: Array.from(participantsMap.values()),
+    events,
+    autonumber: autonumber.on === true || autonumber.on === false ? autonumber : { on: false }
+  };
+}
+var init_sequence_builder = __esm({
+  "node_modules/@probelabs/maid/out/renderer/sequence-builder.js"() {
+    init_lexer4();
+    init_parser4();
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/sequence-layout.js
+function layoutSequence(model) {
+  const order = [];
+  const seen = /* @__PURE__ */ new Set();
+  const partById = new Map(model.participants.map((p3) => [p3.id, p3]));
+  function touch(id) {
+    if (!seen.has(id)) {
+      seen.add(id);
+      order.push(id);
+    }
+  }
+  for (const ev of model.events) {
+    if (ev.kind === "message") {
+      touch(ev.msg.from);
+      touch(ev.msg.to);
+    }
+    if (ev.kind === "note") {
+      ev.note.actors.forEach(touch);
+    }
+    if (ev.kind === "activate" || ev.kind === "deactivate" || ev.kind === "create" || ev.kind === "destroy")
+      touch(ev.actor);
+  }
+  for (const p3 of model.participants)
+    touch(p3.id);
+  const participants = [];
+  let x3 = MARGIN_X;
+  for (const id of order) {
+    const p3 = partById.get(id) || { id, display: id };
+    const w3 = Math.max(COL_MIN, measureText(p3.display, ACTOR_FONT_SIZE) + ACTOR_PAD_X * 2);
+    participants.push({ id, display: p3.display, x: x3, y: MARGIN_Y, width: w3, height: ACTOR_H });
+    x3 += w3 + MARGIN_X;
+  }
+  const width = Math.max(320, x3);
+  const rowIndexForEvent = /* @__PURE__ */ new Map();
+  let row = 0;
+  const openBlocks = [];
+  function consumeRow(idx) {
+    rowIndexForEvent.set(idx, row++);
+  }
+  model.events.forEach((ev, idx) => {
+    switch (ev.kind) {
+      case "message":
+        consumeRow(idx);
+        break;
+      case "note":
+        consumeRow(idx);
+        break;
+      case "block-start":
+        openBlocks.push({ block: ev.block, startRow: row, branches: [] });
+        consumeRow(idx);
+        break;
+      case "block-branch": {
+        const top = openBlocks[openBlocks.length - 1];
+        if (top)
+          top.branches.push({ title: ev.branch.title, row });
+        consumeRow(idx);
+        break;
+      }
+      case "block-end":
+        break;
+      case "activate":
+      case "deactivate":
+      case "create":
+      case "destroy":
+      case "noop":
+        break;
+    }
+  });
+  const lifelineTop = MARGIN_Y + ACTOR_H + LIFELINE_GAP;
+  const contentHeight = row * ROW_H;
+  const height = lifelineTop + contentHeight + MARGIN_Y + ACTOR_H;
+  const lifelines = participants.map((p3) => ({ x: p3.x + p3.width / 2, y1: lifelineTop, y2: height - MARGIN_Y - ACTOR_H }));
+  function yForRow(r3) {
+    return lifelineTop + r3 * ROW_H + ROW_H / 2;
+  }
+  const col = new Map(participants.map((p3) => [p3.id, p3]));
+  const messages = [];
+  const notes = [];
+  const blocks = [];
+  const activations = [];
+  const actStack = /* @__PURE__ */ new Map();
+  const startAct = (actor, r3) => {
+    const arr = actStack.get(actor) || [];
+    arr.push(r3);
+    actStack.set(actor, arr);
+  };
+  const endAct = (actor, r3) => {
+    const arr = actStack.get(actor) || [];
+    const start = arr.pop();
+    if (start != null) {
+      const p3 = col.get(actor);
+      if (p3) {
+        activations.push({ actor, x: p3.x + p3.width / 2 - 4, y: yForRow(start) - ROW_H / 2, width: 8, height: yForRow(r3) - yForRow(start) });
+      }
     }
-    function canonicalize(attrs) {
-      var newAttrs = {};
-      _2.forEach(attrs, function(v3, k3) {
-        newAttrs[k3.toLowerCase()] = v3;
-      });
-      return newAttrs;
+    actStack.set(actor, arr);
+  };
+  const openForLayout = [];
+  model.events.forEach((ev, idx) => {
+    const r3 = rowIndexForEvent.has(idx) ? rowIndexForEvent.get(idx) : null;
+    switch (ev.kind) {
+      case "message": {
+        const p1 = col.get(ev.msg.from), p22 = col.get(ev.msg.to);
+        if (p1 && p22 && r3 != null) {
+          const y2 = yForRow(r3);
+          const x1 = p1.x + p1.width / 2;
+          const x22 = p22.x + p22.width / 2;
+          messages.push({ from: p1.id, to: p22.id, text: ev.msg.text, y: y2, x1, x2: x22, line: ev.msg.line, startMarker: ev.msg.startMarker, endMarker: ev.msg.endMarker, async: ev.msg.async });
+          if (ev.msg.activateTarget)
+            startAct(ev.msg.to, r3);
+          if (ev.msg.deactivateTarget)
+            endAct(ev.msg.to, r3);
+          const top = openForLayout[openForLayout.length - 1];
+          if (top)
+            top.lastRow = r3;
+        }
+        break;
+      }
+      case "note": {
+        if (r3 == null)
+          break;
+        const estLines = (text, width2) => {
+          const charsPerLine = Math.max(8, Math.floor((width2 - NOTE_PAD * 2) / 7));
+          const length = text ? text.length : 0;
+          return Math.max(1, Math.ceil(length / charsPerLine));
+        };
+        const y2 = yForRow(r3) - NOTE_PAD;
+        if (ev.note.pos === "over") {
+          const [a3, b3] = ev.note.actors;
+          const p1 = col.get(a3), p22 = b3 ? col.get(b3) : p1;
+          if (p1 && p22) {
+            const left = Math.min(p1.x + p1.width / 2, p22.x + p22.width / 2);
+            const right = Math.max(p1.x + p1.width / 2, p22.x + p22.width / 2);
+            const w3 = right - left + NOTE_PAD * 2;
+            const lines = estLines(ev.note.text, w3);
+            const h3 = Math.max(ROW_H - NOTE_PAD, lines * 16 + NOTE_PAD);
+            notes.push({ x: left - NOTE_PAD, y: y2, width: w3, height: h3, text: ev.note.text, anchor: "over" });
+          }
+        } else {
+          const actor = ev.note.actors[0];
+          const p3 = col.get(actor);
+          if (p3) {
+            const leftSide = ev.note.pos === "leftOf";
+            const x4 = leftSide ? p3.x - NOTE_W - 10 : p3.x + p3.width + 10;
+            const lines = estLines(ev.note.text, NOTE_W);
+            const h3 = Math.max(ROW_H - NOTE_PAD, lines * 16 + NOTE_PAD);
+            notes.push({ x: x4, y: y2, width: NOTE_W, height: h3, text: ev.note.text, anchor: leftSide ? "left" : "right" });
+          }
+        }
+        const top = openForLayout[openForLayout.length - 1];
+        if (top && r3 != null)
+          top.lastRow = r3;
+        break;
+      }
+      case "activate":
+        if (r3 != null)
+          startAct(ev.actor, r3);
+        break;
+      case "deactivate":
+        if (r3 != null)
+          endAct(ev.actor, r3);
+        break;
+      case "block-start": {
+        const startRow = r3 != null ? r3 : row;
+        openForLayout.push({ block: ev.block, startRow, branches: [] });
+        break;
+      }
+      case "block-branch": {
+        const top = openForLayout[openForLayout.length - 1];
+        if (top && r3 != null) {
+          top.branches.push({ title: ev.branch.title, row: r3 });
+          top.lastRow = r3;
+        }
+        break;
+      }
+      case "block-end": {
+        const top = openForLayout.pop();
+        if (top) {
+          const first2 = participants.length > 0 ? participants[0] : void 0;
+          const last2 = participants.length > 0 ? participants[participants.length - 1] : void 0;
+          const left = first2 ? first2.x : MARGIN_X;
+          const right = last2 ? last2.x + last2.width : left + 200;
+          const yTop = yForRow(top.startRow) - ROW_H / 2 - (BLOCK_PAD + TITLE_EXTRA_TOP);
+          const endRow = top.lastRow != null ? top.lastRow : top.startRow;
+          const yBot = yForRow(endRow) + ROW_H / 2 + BLOCK_PAD;
+          const layout = { type: top.block.type, title: top.block.title, x: left - BLOCK_PAD, y: yTop, width: right - left + BLOCK_PAD * 2, height: yBot - yTop };
+          if (top.branches.length)
+            layout.branches = top.branches.map((b3) => ({ title: b3.title, y: yForRow(b3.row) - ROW_H / 2 }));
+          blocks.push(layout);
+        }
+        break;
+      }
+      default:
+        break;
     }
+  });
+  const lastRow = row;
+  for (const [actor, arr] of actStack.entries()) {
+    while (arr.length) {
+      const start = arr.pop();
+      const p3 = col.get(actor);
+      if (p3)
+        activations.push({ actor, x: p3.x + p3.width / 2 - 4, y: yForRow(start) - ROW_H / 2, width: 8, height: yForRow(lastRow) - yForRow(start) });
+    }
+  }
+  return { width, height, participants, lifelines, messages, notes, blocks, activations };
+}
+var MARGIN_X, MARGIN_Y, ACTOR_FONT_SIZE, ACTOR_H, LIFELINE_GAP, ACTOR_PAD_X, COL_MIN, ROW_H, NOTE_W, NOTE_PAD, BLOCK_PAD, TITLE_EXTRA_TOP;
+var init_sequence_layout = __esm({
+  "node_modules/@probelabs/maid/out/renderer/sequence-layout.js"() {
+    init_utils4();
+    MARGIN_X = 24;
+    MARGIN_Y = 24;
+    ACTOR_FONT_SIZE = 16;
+    ACTOR_H = 32;
+    LIFELINE_GAP = 4;
+    ACTOR_PAD_X = 12;
+    COL_MIN = 110;
+    ROW_H = 36;
+    NOTE_W = 160;
+    NOTE_PAD = 8;
+    BLOCK_PAD = 8;
+    TITLE_EXTRA_TOP = 12;
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/sequence-renderer.js
+function renderSequence(model, opts = {}) {
+  const layout = layoutSequence(model);
+  const svgParts = [];
+  const width = Math.ceil(layout.width);
+  const height = Math.ceil(layout.height);
+  svgParts.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${width + 50}" height="${height + 40}" viewBox="-50 -10 ${width + 50} ${height + 40}">`);
+  const sharedCss = buildSharedCss({
+    fontFamily: "Arial, sans-serif",
+    fontSize: 14,
+    nodeFill: "#eef0ff",
+    nodeStroke: "#3f3f3f",
+    edgeStroke: "#555555"
+  });
+  svgParts.push(`  <style>${sharedCss}</style>`);
+  for (const p3 of layout.participants)
+    drawParticipant(svgParts, p3);
+  for (const b3 of layout.blocks)
+    svgParts.push(blockBackground(b3.x, b3.y, b3.width, b3.height, 0));
+  for (const l3 of layout.lifelines)
+    svgParts.push(`  <line class="lifeline" x1="${l3.x}" y1="${l3.y1}" x2="${l3.x}" y2="${l3.y2}"/>`);
+  for (const a3 of layout.activations)
+    svgParts.push(`  <rect class="activation" x="${a3.x}" y="${a3.y}" width="${a3.width}" height="${a3.height}" />`);
+  let counter = model.autonumber?.on ? model.autonumber.start ?? 1 : void 0;
+  const step = model.autonumber?.on ? model.autonumber.step ?? 1 : void 0;
+  for (const m3 of layout.messages) {
+    drawMessage(svgParts, m3);
+    const label = formatMessageLabel(m3.text, counter);
+    if (label)
+      drawMessageLabel(svgParts, m3, label, counter);
+    if (counter != null)
+      counter += step;
+  }
+  for (const n3 of layout.notes)
+    drawNote(svgParts, n3);
+  for (const b3 of layout.blocks) {
+    const title = b3.title ? `${b3.type}: ${b3.title}` : b3.type;
+    const branches = (b3.branches || []).map((br) => ({ y: br.y, title: br.title }));
+    svgParts.push(blockOverlay(b3.x, b3.y, b3.width, b3.height, title, branches, 0, "left", "left", 0));
+  }
+  for (const p3 of layout.participants)
+    drawParticipantBottom(svgParts, p3, layout);
+  svgParts.push("</svg>");
+  let svg = svgParts.join("\n");
+  if (opts.theme)
+    svg = applySequenceTheme(svg, opts.theme);
+  return svg;
+}
+function drawParticipant(out, p3) {
+  out.push(`  <g class="actor" transform="translate(${p3.x},${p3.y})">`);
+  out.push(`    <rect class="node-shape" width="${p3.width}" height="${p3.height}" rx="0"/>`);
+  out.push(`    <text class="node-label" x="${p3.width / 2}" y="${p3.height / 2}" text-anchor="middle" dominant-baseline="middle">${escapeXml(p3.display)}</text>`);
+  out.push("  </g>");
+}
+function drawParticipantBottom(out, p3, layout) {
+  const lifeline = layout.lifelines.find((l3) => Math.abs(l3.x - (p3.x + p3.width / 2)) < 1e-3);
+  const y2 = lifeline ? lifeline.y2 : layout.height - 28;
+  out.push(`  <g class="actor" transform="translate(${p3.x},${y2})">`);
+  out.push(`    <rect class="node-shape" width="${p3.width}" height="${p3.height}" rx="0"/>`);
+  out.push(`    <text class="node-label" x="${p3.width / 2}" y="${p3.height / 2}" text-anchor="middle" dominant-baseline="middle">${escapeXml(p3.display)}</text>`);
+  out.push("  </g>");
+}
+function drawMessage(out, m3) {
+  const cls = `msg-line ${m3.line}`.trim();
+  const x1 = m3.x1, x22 = m3.x2, y2 = m3.y;
+  out.push(`  <path class="${cls}" d="M ${x1} ${y2} L ${x22} ${y2}" />`);
+  const start = { x: x1, y: y2 };
+  const end = { x: x22, y: y2 };
+  if (m3.endMarker === "arrow")
+    out.push("  " + triangleAtEnd(start, end));
+  if (m3.startMarker === "arrow")
+    out.push("  " + triangleAtStart(start, end));
+  if (m3.endMarker === "open")
+    out.push(`  <circle class="openhead" cx="${x22}" cy="${y2}" r="4" />`);
+  if (m3.startMarker === "open")
+    out.push(`  <circle class="openhead" cx="${x1}" cy="${y2}" r="4" />`);
+  if (m3.endMarker === "cross")
+    out.push(`  <g class="crosshead" transform="translate(${x22},${y2})"><path d="M -4 -4 L 4 4"/><path d="M -4 4 L 4 -4"/></g>`);
+  if (m3.startMarker === "cross")
+    out.push(`  <g class="crosshead" transform="translate(${x1},${y2})"><path d="M -4 -4 L 4 4"/><path d="M -4 4 L 4 -4"/></g>`);
+}
+function formatMessageLabel(text, counter) {
+  if (!text && counter == null)
+    return void 0;
+  if (counter != null && text)
+    return `${counter}: ${text}`;
+  if (counter != null)
+    return String(counter);
+  return text;
+}
+function drawMessageLabel(out, m3, label, _counter) {
+  const xMid = (m3.x1 + m3.x2) / 2;
+  const h3 = 16;
+  const w3 = Math.max(20, measureText(label, 12) + 10);
+  const x3 = xMid - w3 / 2;
+  const y2 = m3.y - 10 - h3 / 2;
+  out.push(`  <rect class="msg-label-bg" x="${x3}" y="${y2}" width="${w3}" height="${h3}" rx="0"/>`);
+  out.push(`  <text class="msg-label" x="${xMid}" y="${y2 + h3 / 2}" text-anchor="middle">${escapeXml(label)}</text>`);
+}
+function drawNote(out, n3) {
+  out.push(`  <g class="note" transform="translate(${n3.x},${n3.y})">`);
+  out.push(`    <rect width="${n3.width}" height="${n3.height}" rx="0"/>`);
+  out.push(`    <text class="note-text" x="${n3.width / 2}" y="${n3.height / 2 + 4}" text-anchor="middle">${escapeXml(n3.text)}</text>`);
+  out.push("  </g>");
+}
+function applySequenceTheme(svg, theme) {
+  let out = svg;
+  if (theme.actorBkg)
+    out = out.replace(/\.actor-rect\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.actorBkg)};`));
+  if (theme.actorBorder)
+    out = out.replace(/\.actor-rect\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.actorBorder)};`));
+  if (theme.actorTextColor)
+    out = out.replace(/\.actor-label\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.actorTextColor)};`));
+  if (theme.lifelineColor)
+    out = out.replace(/\.lifeline\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.lifelineColor)};`));
+  if (theme.lineColor)
+    out = out.replace(/\.msg-line\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.lineColor)};`));
+  if (theme.arrowheadColor) {
+    out = out.replace(/\.arrowhead\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.arrowheadColor)};`));
+    out = out.replace(/\.openhead\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.arrowheadColor)};`));
+    out = out.replace(/\.crosshead\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.arrowheadColor)};`));
+  }
+  if (theme.noteBkg)
+    out = out.replace(/\.note\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.noteBkg)};`));
+  if (theme.noteBorder)
+    out = out.replace(/\.note\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.noteBorder)};`));
+  if (theme.noteTextColor)
+    out = out.replace(/\.note-text\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.noteTextColor)};`));
+  if (theme.activationBkg)
+    out = out.replace(/\.activation\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.activationBkg)};`));
+  if (theme.activationBorder)
+    out = out.replace(/\.activation\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.activationBorder)};`));
+  return out;
+}
+var init_sequence_renderer = __esm({
+  "node_modules/@probelabs/maid/out/renderer/sequence-renderer.js"() {
+    init_sequence_layout();
+    init_utils4();
+    init_arrow_utils();
+    init_block_utils();
+    init_styles();
   }
 });
 
-// node_modules/dagre/lib/debug.js
-var require_debug = __commonJS({
-  "node_modules/dagre/lib/debug.js"(exports2, module2) {
-    var _2 = require_lodash2();
-    var util = require_util();
-    var Graph = require_graphlib2().Graph;
-    module2.exports = {
-      debugOrdering
-    };
-    function debugOrdering(g3) {
-      var layerMatrix = util.buildLayerMatrix(g3);
-      var h3 = new Graph({ compound: true, multigraph: true }).setGraph({});
-      _2.forEach(g3.nodes(), function(v3) {
-        h3.setNode(v3, { label: v3 });
-        h3.setParent(v3, "layer" + g3.node(v3).rank);
-      });
-      _2.forEach(g3.edges(), function(e3) {
-        h3.setEdge(e3.v, e3.w, {}, e3.name);
-      });
-      _2.forEach(layerMatrix, function(layer, i3) {
-        var layerV = "layer" + i3;
-        h3.setNode(layerV, { rank: "same" });
-        _2.reduce(layer, function(u3, v3) {
-          h3.setEdge(u3, v3, { style: "invis" });
-          return v3;
-        });
-      });
-      return h3;
+// node_modules/@probelabs/maid/out/core/frontmatter.js
+function parseFrontmatter(input) {
+  const text = input.startsWith("\uFEFF") ? input.slice(1) : input;
+  const lines = text.split(/\r?\n/);
+  if (lines.length < 3 || lines[0].trim() !== "---")
+    return null;
+  let i3 = 1;
+  const block = [];
+  while (i3 < lines.length && lines[i3].trim() !== "---") {
+    block.push(lines[i3]);
+    i3++;
+  }
+  if (i3 >= lines.length)
+    return null;
+  const body = lines.slice(i3 + 1).join("\n");
+  const raw = block.join("\n");
+  const config = {};
+  const themeVars = {};
+  let themeUnderConfig = false;
+  let ctx = "root";
+  for (const line of block) {
+    if (!line.trim())
+      continue;
+    const indent = line.match(/^\s*/)?.[0].length ?? 0;
+    const mKey = line.match(/^\s*([A-Za-z0-9_\-]+):\s*(.*)$/);
+    if (!mKey)
+      continue;
+    const key = mKey[1];
+    let value = mKey[2] || "";
+    if (indent === 0) {
+      if (key === "config") {
+        ctx = "config";
+        continue;
+      }
+      if (key === "themeVariables") {
+        ctx = "theme";
+        continue;
+      }
+      ctx = "root";
+      continue;
+    }
+    if (ctx === "config") {
+      if (indent <= 2 && key !== "pie" && key !== "themeVariables")
+        continue;
+      if (key === "pie") {
+        ctx = "config.pie";
+        ensure(config, "pie", {});
+        continue;
+      }
+      if (key === "themeVariables") {
+        ctx = "theme";
+        themeUnderConfig = true;
+        continue;
+      }
+      continue;
+    }
+    if (ctx === "config.pie") {
+      if (indent < 4) {
+        if (key === "pie") {
+          ctx = "config.pie";
+          ensure(config, "pie", {});
+          continue;
+        }
+        if (key === "themeVariables") {
+          ctx = "theme";
+          themeUnderConfig = true;
+          continue;
+        }
+        ctx = "config";
+        continue;
+      }
+      setKV(config.pie, key, value);
+      continue;
+    }
+    if (ctx === "theme") {
+      if (indent < 2) {
+        ctx = "root";
+        continue;
+      }
+      setKV(themeVars, key, value);
+      continue;
     }
   }
-});
-
-// node_modules/dagre/lib/version.js
-var require_version2 = __commonJS({
-  "node_modules/dagre/lib/version.js"(exports2, module2) {
-    module2.exports = "0.8.5";
+  if (themeUnderConfig && Object.keys(themeVars).length) {
+    ensure(config, "themeVariables", {});
+    Object.assign(config.themeVariables, themeVars);
   }
-});
-
-// node_modules/dagre/index.js
-var require_dagre = __commonJS({
-  "node_modules/dagre/index.js"(exports2, module2) {
-    module2.exports = {
-      graphlib: require_graphlib2(),
-      layout: require_layout(),
-      debug: require_debug(),
-      util: {
-        time: require_util().time,
-        notime: require_util().notime
-      },
-      version: require_version2()
-    };
+  return { raw, body, config: Object.keys(config).length ? config : void 0, themeVariables: Object.keys(themeVars).length ? themeVars : void 0 };
+}
+function ensure(obj, key, def) {
+  if (obj[key] == null)
+    obj[key] = def;
+}
+function unquote2(val) {
+  const v3 = val.trim();
+  if (v3.startsWith('"') && v3.endsWith('"') || v3.startsWith("'") && v3.endsWith("'")) {
+    return v3.slice(1, -1);
   }
-});
-
-// node_modules/@probelabs/maid/out/renderer/layout.js
-var import_dagre;
-var init_layout = __esm({
-  "node_modules/@probelabs/maid/out/renderer/layout.js"() {
-    import_dagre = __toESM(require_dagre(), 1);
+  return v3;
+}
+function setKV(target, key, rawValue) {
+  const v3 = unquote2(rawValue);
+  if (v3 === "") {
+    target[key] = "";
+    return;
   }
-});
-
-// node_modules/@probelabs/maid/out/renderer/svg-generator.js
-var init_svg_generator = __esm({
-  "node_modules/@probelabs/maid/out/renderer/svg-generator.js"() {
+  const num = Number(v3);
+  if (!Number.isNaN(num) && /^-?[0-9]+(\.[0-9]+)?$/.test(v3)) {
+    target[key] = num;
+    return;
+  }
+  if (/^(true|false)$/i.test(v3)) {
+    target[key] = /^true$/i.test(v3);
+    return;
+  }
+  target[key] = v3;
+}
+var init_frontmatter = __esm({
+  "node_modules/@probelabs/maid/out/core/frontmatter.js"() {
   }
 });
 
@@ -53452,6 +56595,102 @@ var init_dot_renderer = __esm({
 });
 
 // node_modules/@probelabs/maid/out/renderer/index.js
+function applyPieTheme(svg, theme) {
+  if (!theme)
+    return svg;
+  let out = svg;
+  if (theme.pieOuterStrokeWidth != null || theme.pieStrokeColor) {
+    out = out.replace(/\.pieOuterCircle\s*\{[^}]*\}/, (m3) => {
+      let rule = m3;
+      if (theme.pieStrokeColor)
+        rule = rule.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.pieStrokeColor)};`);
+      if (theme.pieOuterStrokeWidth != null)
+        rule = rule.replace(/stroke-width:\s*[^;]+;/, `stroke-width: ${String(theme.pieOuterStrokeWidth)};`);
+      return rule;
+    });
+    if (theme.pieStrokeColor) {
+      out = out.replace(/\.pieCircle\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.pieStrokeColor)};`));
+    }
+  }
+  if (theme.pieSectionTextColor) {
+    const c3 = String(theme.pieSectionTextColor);
+    out = out.replace(/\.slice-label \{[^}]*\}/, (m3) => m3.replace(/fill:\s*#[0-9A-Fa-f]{3,8}|fill:\s*rgb\([^)]*\)/, `fill: ${c3}`));
+    out = out.replace(/<text class="slice-label"([^>]*)>/g, `<text class="slice-label"$1 fill="${c3}">`);
+  }
+  if (theme.pieTitleTextColor) {
+    const c3 = String(theme.pieTitleTextColor);
+    out = out.replace(/<text class="pie-title"([^>]*)>/g, `<text class="pie-title"$1 fill="${c3}">`);
+  }
+  if (theme.pieSectionTextSize) {
+    const size = String(theme.pieSectionTextSize);
+    out = out.replace(/<text class="slice-label"([^>]*)>/g, `<text class="slice-label"$1 font-size="${size}">`);
+  }
+  if (theme.pieTitleTextSize) {
+    const size = String(theme.pieTitleTextSize);
+    out = out.replace(/<text class="pie-title"([^>]*)>/g, `<text class="pie-title"$1 font-size="${size}">`);
+  }
+  const colors = [];
+  for (let i3 = 1; i3 <= 24; i3++) {
+    const key = "pie" + i3;
+    if (theme[key])
+      colors.push(String(theme[key]));
+  }
+  if (colors.length) {
+    let idx = 0;
+    out = out.replace(/<path[^>]*class="pieCircle"[^>]*\sfill="([^"]+)"/g, (_m2) => {
+      const color = colors[idx] ?? null;
+      idx++;
+      if (color)
+        return _m2.replace(/fill="([^"]+)"/, `fill="${color}"`);
+      return _m2;
+    });
+  }
+  return out;
+}
+function applyFlowchartTheme(svg, theme) {
+  if (!theme)
+    return svg;
+  let out = svg;
+  if (theme.nodeBkg || theme.nodeBorder) {
+    out = out.replace(/\.node-shape\s*\{[^}]*\}/, (m3) => {
+      let rule = m3;
+      if (theme.nodeBkg)
+        rule = rule.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.nodeBkg)};`);
+      if (theme.nodeBorder)
+        rule = rule.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.nodeBorder)};`);
+      return rule;
+    });
+  }
+  if (theme.nodeTextColor) {
+    out = out.replace(/\.node-label\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.nodeTextColor)};`));
+  }
+  if (theme.lineColor) {
+    out = out.replace(/\.edge-path\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.lineColor)};`));
+  }
+  if (theme.arrowheadColor) {
+    out = out.replace(/(<path d="M0,0 L0,[0-9.]+ L[0-9.]+,[0-9.]+ z"[^>]*)(fill="[^"]*")/g, (_m2, p1) => `${p1}fill="${String(theme.arrowheadColor)}"`);
+    out = out.replace(/(<circle cx="4\.5" cy="4\.5" r="4\.5"[^>]*)(fill="[^"]*")/g, (_m2, p1) => `${p1}fill="${String(theme.arrowheadColor)}"`);
+  }
+  if (theme.clusterBkg) {
+    out = out.replace(/\.cluster-bg\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.clusterBkg)};`));
+  }
+  if (theme.clusterBorder) {
+    out = out.replace(/\.cluster-border\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.clusterBorder)};`));
+  }
+  if (theme.clusterTextColor) {
+    out = out.replace(/\.cluster-label-text\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.clusterTextColor)};`));
+  }
+  if (theme.fontFamily)
+    out = out.replace(/\.node-label\s*\{[^}]*\}/, (m3) => m3.replace(/font-family:\s*[^;]+;/, `font-family: ${String(theme.fontFamily)};`));
+  if (theme.fontSize)
+    out = out.replace(/\.node-label\s*\{[^}]*\}/, (m3) => m3.replace(/font-size:\s*[^;]+;/, `font-size: ${String(theme.fontSize)};`));
+  return out;
+}
+function renderMermaid(text, options = {}) {
+  const renderer = new MermaidRenderer(options.layoutEngine, options.renderer);
+  return renderer.renderAny(text, options);
+}
+var MermaidRenderer;
 var init_renderer = __esm({
   "node_modules/@probelabs/maid/out/renderer/index.js"() {
     init_lexer2();
@@ -53459,9 +56698,244 @@ var init_renderer = __esm({
     init_graph_builder();
     init_layout();
     init_svg_generator();
+    init_pie_builder();
+    init_pie_renderer();
+    init_sequence_builder();
+    init_sequence_renderer();
+    init_frontmatter();
     init_layout();
     init_svg_generator();
     init_dot_renderer();
+    MermaidRenderer = class {
+      constructor(layoutEngine, renderer) {
+        this.graphBuilder = new GraphBuilder();
+        this.layoutEngine = layoutEngine || new DagreLayoutEngine();
+        this.renderer = renderer || new SVGRenderer();
+      }
+      /**
+       * Renders a Mermaid flowchart diagram
+       */
+      render(text, options = {}) {
+        const errors = [];
+        const layoutEngine = options.layoutEngine || this.layoutEngine;
+        const renderer = options.renderer || this.renderer;
+        try {
+          const lexResult = tokenize(text);
+          if (lexResult.errors && lexResult.errors.length > 0) {
+            for (const error2 of lexResult.errors) {
+              errors.push({
+                line: error2.line || 1,
+                column: error2.column || 1,
+                message: error2.message,
+                severity: "error",
+                code: "LEXER_ERROR"
+              });
+            }
+          }
+          parserInstance.reset();
+          parserInstance.input = lexResult.tokens;
+          const cst = parserInstance.diagram();
+          if (parserInstance.errors && parserInstance.errors.length > 0) {
+            for (const error2 of parserInstance.errors) {
+              const token = error2.token;
+              errors.push({
+                line: token?.startLine || 1,
+                column: token?.startColumn || 1,
+                message: error2.message,
+                severity: "error",
+                code: "PARSER_ERROR"
+              });
+            }
+          }
+          const graph = this.graphBuilder.build(cst);
+          let layout;
+          try {
+            layout = layoutEngine.layout(graph);
+          } catch (layoutError) {
+            errors.push({
+              line: 1,
+              column: 1,
+              message: layoutError.message || "Layout calculation failed",
+              severity: "error",
+              code: "LAYOUT_ERROR"
+            });
+            return {
+              svg: this.generateErrorSvg(layoutError.message || "Layout calculation failed"),
+              graph,
+              errors
+            };
+          }
+          let svg = renderer.render(layout);
+          if (options.showErrors && errors.length > 0) {
+            svg = this.addErrorOverlays(svg, errors);
+          }
+          return {
+            svg,
+            graph,
+            errors
+          };
+        } catch (error2) {
+          const errorSvg = this.generateErrorSvg(error2.message || "Unknown error occurred");
+          errors.push({
+            line: 1,
+            column: 1,
+            message: error2.message || "Unknown error occurred",
+            severity: "error",
+            code: "RENDER_ERROR"
+          });
+          return {
+            svg: errorSvg,
+            graph: { nodes: [], edges: [], direction: "TD" },
+            errors
+          };
+        }
+      }
+      /**
+       * Renders supported diagram types (flowchart + pie for now)
+       */
+      renderAny(text, options = {}) {
+        let content = text;
+        let theme;
+        if (text.trimStart().startsWith("---")) {
+          const fm = parseFrontmatter(text);
+          if (fm) {
+            content = fm.body;
+            theme = fm.themeVariables || fm.config && fm.config.themeVariables || void 0;
+          }
+        }
+        const firstLine = content.trim().split("\n")[0];
+        if (/^(flowchart|graph)\s+/i.test(firstLine)) {
+          const res = this.render(content, options);
+          const svg2 = theme ? applyFlowchartTheme(res.svg, theme) : res.svg;
+          return { svg: svg2, graph: res.graph, errors: res.errors };
+        }
+        if (/^pie\b/i.test(firstLine)) {
+          try {
+            const { model, errors } = buildPieModel(content);
+            const svg = renderPie(model, {
+              width: options.width,
+              height: options.height,
+              rimStroke: theme?.pieStrokeColor,
+              rimStrokeWidth: theme?.pieOuterStrokeWidth
+            });
+            const themedSvg = applyPieTheme(svg, theme);
+            return { svg: themedSvg, graph: { nodes: [], edges: [], direction: "TD" }, errors };
+          } catch (e3) {
+            const msg = e3?.message || "Pie render error";
+            const err = [{ line: 1, column: 1, message: msg, severity: "error", code: "PIE_RENDER" }];
+            return { svg: this.generateErrorSvg(msg), graph: { nodes: [], edges: [], direction: "TD" }, errors: err };
+          }
+        }
+        if (/^sequenceDiagram\b/.test(firstLine)) {
+          try {
+            const model = buildSequenceModel(content);
+            const svg = renderSequence(model, { theme });
+            return { svg, graph: { nodes: [], edges: [], direction: "TD" }, errors: [] };
+          } catch (e3) {
+            const msg = e3?.message || "Sequence render error";
+            const err = [{ line: 1, column: 1, message: msg, severity: "error", code: "SEQUENCE_RENDER" }];
+            return { svg: this.generateErrorSvg(msg), graph: { nodes: [], edges: [], direction: "TD" }, errors: err };
+          }
+        }
+        const errorSvg = this.generateErrorSvg("Unsupported diagram type. Rendering supports flowchart, pie, and sequence for now.");
+        return {
+          svg: errorSvg,
+          graph: { nodes: [], edges: [], direction: "TD" },
+          errors: [{
+            line: 1,
+            column: 1,
+            message: "Unsupported diagram type",
+            severity: "error",
+            code: "UNSUPPORTED_TYPE"
+          }]
+        };
+      }
+      addErrorOverlays(svg, errors) {
+        const errorStyle = `
+    <style>
+      .error-indicator {
+        fill: #ff0000;
+        opacity: 0.8;
+      }
+      .error-text {
+        fill: white;
+        font-family: Arial, sans-serif;
+        font-size: 12px;
+        font-weight: bold;
+      }
+    </style>`;
+        const errorIndicator = `
+    <g id="errors">
+      <rect x="5" y="5" width="100" height="25" rx="3" class="error-indicator" />
+      <text x="55" y="20" text-anchor="middle" class="error-text">${errors.length} error${errors.length !== 1 ? "s" : ""}</text>
+    </g>`;
+        return svg.replace("</svg>", `${errorStyle}${errorIndicator}</svg>`);
+      }
+      generateErrorSvg(message) {
+        const width = 400;
+        const height = 200;
+        return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+  <rect width="${width}" height="${height}" fill="#fee" stroke="#c00" stroke-width="2" />
+  <text x="${width / 2}" y="${height / 2 - 20}" text-anchor="middle" font-family="Arial, sans-serif" font-size="16" fill="#c00">
+    Render Error
+  </text>
+  <text x="${width / 2}" y="${height / 2 + 10}" text-anchor="middle" font-family="Arial, sans-serif" font-size="12" fill="#666">
+    ${this.wrapText(message, 40).map((line, i3) => `<tspan x="${width / 2}" dy="${i3 === 0 ? 0 : 15}">${this.escapeXml(line)}</tspan>`).join("")}
+  </text>
+</svg>`;
+      }
+      wrapText(text, maxLength) {
+        const words = text.split(" ");
+        const lines = [];
+        let currentLine = "";
+        for (const word of words) {
+          if (currentLine.length + word.length + 1 <= maxLength) {
+            currentLine += (currentLine ? " " : "") + word;
+          } else {
+            if (currentLine)
+              lines.push(currentLine);
+            currentLine = word;
+          }
+        }
+        if (currentLine)
+          lines.push(currentLine);
+        return lines.slice(0, 3);
+      }
+      escapeXml(text) {
+        return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+      }
+    };
+  }
+});
+
+// node_modules/@probelabs/maid/out/mermaid-compat.js
+function createMermaidAPI() {
+  return {
+    initialize(_config) {
+    },
+    async render(_id, text, options) {
+      try {
+        const result = renderMermaid(text, options);
+        return { svg: result.svg };
+      } catch (error2) {
+        throw new Error(`Maid render failed: ${error2.message || "Unknown error"}`);
+      }
+    },
+    renderSync(_id, text, options) {
+      try {
+        const result = renderMermaid(text, options);
+        return { svg: result.svg };
+      } catch (error2) {
+        throw new Error(`Maid render failed: ${error2.message || "Unknown error"}`);
+      }
+    }
+  };
+}
+var maid;
+var init_mermaid_compat = __esm({
+  "node_modules/@probelabs/maid/out/mermaid-compat.js"() {
+    init_renderer();
+    maid = createMermaidAPI();
   }
 });
 
@@ -53495,6 +56969,7 @@ var init_out = __esm({
     init_edits();
     init_fixes();
     init_renderer();
+    init_mermaid_compat();
     init_router();
     init_fixes();
     init_edits();
@@ -54210,8 +57685,8 @@ When presented with a broken Mermaid diagram, analyze it thoroughly and provide
             debug: this.options.debug,
             tracer: this.options.tracer,
             allowEdit: this.options.allowEdit,
-            maxIterations: 2,
-            // Limit mermaid fixing to 2 iterations to prevent long loops
+            maxIterations: 10,
+            // Allow more iterations for mermaid fixing to handle complex diagrams
             disableMermaidValidation: true
             // CRITICAL: Disable mermaid validation in nested agent to prevent infinite recursion
           });
@@ -55111,6 +58586,18 @@ var init_ProbeAgent = __esm({
           this.toolImplementations.bash = wrappedTools.bashToolInstance;
         }
         this.wrappedTools = wrappedTools;
+        if (this.debug) {
+          console.error("\n[DEBUG] ========================================");
+          console.error("[DEBUG] ProbeAgent Tools Initialized");
+          console.error("[DEBUG] Session ID:", this.sessionId);
+          console.error("[DEBUG] Available tools:");
+          for (const toolName of Object.keys(this.toolImplementations)) {
+            console.error(`[DEBUG]   - ${toolName}`);
+          }
+          console.error("[DEBUG] Allowed folders:", this.allowedFolders);
+          console.error("[DEBUG] Outline mode:", this.outline);
+          console.error("[DEBUG] ========================================\n");
+        }
       }
       /**
        * Initialize the AI model based on available API keys and forced provider setting
@@ -55881,12 +59368,28 @@ You are working with a repository located at: ${searchDirectory}
                 const { type } = parsedTool;
                 if (type === "mcp" && this.mcpBridge && this.mcpBridge.isMcpTool(toolName)) {
                   try {
-                    if (this.debug) console.log(`[DEBUG] Executing MCP tool '${toolName}' with params:`, params);
+                    if (this.debug) {
+                      console.error(`
+[DEBUG] ========================================`);
+                      console.error(`[DEBUG] Executing MCP tool: ${toolName}`);
+                      console.error(`[DEBUG] Arguments:`);
+                      for (const [key, value] of Object.entries(params)) {
+                        const displayValue = typeof value === "string" && value.length > 100 ? value.substring(0, 100) + "..." : value;
+                        console.error(`[DEBUG]   ${key}: ${JSON.stringify(displayValue)}`);
+                      }
+                      console.error(`[DEBUG] ========================================
+`);
+                    }
                     const executionResult = await this.mcpBridge.mcpTools[toolName].execute(params);
                     const toolResultContent = typeof executionResult === "string" ? executionResult : JSON.stringify(executionResult, null, 2);
-                    const preview = createMessagePreview(toolResultContent);
                     if (this.debug) {
-                      console.log(`[DEBUG] MCP tool '${toolName}' executed successfully. Result preview: ${preview}`);
+                      const preview = toolResultContent.length > 500 ? toolResultContent.substring(0, 500) + "..." : toolResultContent;
+                      console.error(`[DEBUG] ========================================`);
+                      console.error(`[DEBUG] MCP tool '${toolName}' completed successfully`);
+                      console.error(`[DEBUG] Result preview:`);
+                      console.error(preview);
+                      console.error(`[DEBUG] ========================================
+`);
                     }
                     currentMessages.push({ role: "user", content: `<tool_result>
 ${toolResultContent}
@@ -55894,7 +59397,13 @@ ${toolResultContent}
                   } catch (error2) {
                     console.error(`Error executing MCP tool ${toolName}:`, error2);
                     const toolResultContent = `Error executing MCP tool ${toolName}: ${error2.message}`;
-                    if (this.debug) console.log(`[DEBUG] MCP tool '${toolName}' execution FAILED.`);
+                    if (this.debug) {
+                      console.error(`[DEBUG] ========================================`);
+                      console.error(`[DEBUG] MCP tool '${toolName}' failed with error:`);
+                      console.error(`[DEBUG] ${error2.message}`);
+                      console.error(`[DEBUG] ========================================
+`);
+                    }
                     currentMessages.push({ role: "user", content: `<tool_result>
 ${toolResultContent}
 </tool_result>` });
@@ -55906,6 +59415,18 @@ ${toolResultContent}
                       sessionId: this.sessionId,
                       workingDirectory: this.allowedFolders && this.allowedFolders[0] || process.cwd()
                     };
+                    if (this.debug) {
+                      console.error(`
+[DEBUG] ========================================`);
+                      console.error(`[DEBUG] Executing tool: ${toolName}`);
+                      console.error(`[DEBUG] Arguments:`);
+                      for (const [key, value] of Object.entries(params)) {
+                        const displayValue = typeof value === "string" && value.length > 100 ? value.substring(0, 100) + "..." : value;
+                        console.error(`[DEBUG]   ${key}: ${JSON.stringify(displayValue)}`);
+                      }
+                      console.error(`[DEBUG] ========================================
+`);
+                    }
                     this.events.emit("toolCall", {
                       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                       name: toolName,
@@ -55947,6 +59468,15 @@ ${toolResultContent}
                       } else {
                         toolResult = await executeToolCall();
                       }
+                      if (this.debug) {
+                        const resultPreview = typeof toolResult === "string" ? toolResult.length > 500 ? toolResult.substring(0, 500) + "..." : toolResult : toolResult ? JSON.stringify(toolResult, null, 2).substring(0, 500) + "..." : "No Result";
+                        console.error(`[DEBUG] ========================================`);
+                        console.error(`[DEBUG] Tool '${toolName}' completed successfully`);
+                        console.error(`[DEBUG] Result preview:`);
+                        console.error(resultPreview);
+                        console.error(`[DEBUG] ========================================
+`);
+                      }
                       this.events.emit("toolCall", {
                         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                         name: toolName,
@@ -55955,6 +59485,13 @@ ${toolResultContent}
                         status: "completed"
                       });
                     } catch (toolError) {
+                      if (this.debug) {
+                        console.error(`[DEBUG] ========================================`);
+                        console.error(`[DEBUG] Tool '${toolName}' failed with error:`);
+                        console.error(`[DEBUG] ${toolError.message}`);
+                        console.error(`[DEBUG] ========================================
+`);
+                      }
                       this.events.emit("toolCall", {
                         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                         name: toolName,
@@ -56004,6 +59541,16 @@ Error: Unknown tool '${toolName}'. Available tools: ${allAvailableTools.join(",
                 }
               }
             } else {
+              const hasMermaidCodeBlock = /```mermaid\s*\n[\s\S]*?\n```/.test(assistantResponseContent);
+              const hasNoSchemaOrTools = !options.schema && validTools.length === 0;
+              if (hasMermaidCodeBlock && hasNoSchemaOrTools) {
+                finalResult = assistantResponseContent;
+                completionAttempted = true;
+                if (this.debug) {
+                  console.error(`[DEBUG] Accepting mermaid code block as valid completion (no schema, no tools)`);
+                }
+                break;
+              }
               currentMessages.push({ role: "assistant", content: assistantResponseContent });
               let reminderContent;
               if (options.schema) {