@probelabs/visor 0.1.71 → 0.1.73

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-process.env.VISOR_VERSION = '0.1.71';
-process.env.PROBE_VERSION = '0.6.0-rc115';
+process.env.VISOR_VERSION = '0.1.73';
+process.env.PROBE_VERSION = '0.6.0-rc117';
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -94483,6 +94483,11 @@ ${prInfo.fullDiff ? this.escapeXml(prInfo.fullDiff) : ''}
                 allowEdit: false, // We don't want the agent to modify files
                 debug: this.config.debug || false,
             };
+            // Wire MCP configuration when provided
+            if (this.config.mcpServers && Object.keys(this.config.mcpServers).length > 0) {
+                options.enableMcp = true;
+                options.mcpConfig = { mcpServers: this.config.mcpServers };
+            }
             // Add provider-specific options if configured
             if (this.config.provider) {
                 // Map claude-code to anthropic for ProbeAgent compatibility
@@ -95094,6 +95099,7 @@ class CheckExecutionEngine {
     config;
     webhookContext;
     routingSandbox;
+    executionStats = new Map();
     constructor(workingDirectory) {
         this.workingDirectory = workingDirectory || process.cwd();
         this.gitAnalyzer = new git_repository_analyzer_1.GitRepositoryAnalyzer(this.workingDirectory);
@@ -95655,12 +95661,15 @@ class CheckExecutionEngine {
                     apiCallDetails: reviewSummary.debug.apiCallDetails,
                 };
             }
+            // Build execution statistics
+            const executionStatistics = this.buildExecutionStatistics();
             return {
                 repositoryInfo,
                 reviewSummary,
                 executionTime,
                 timestamp,
                 checksExecuted: filteredChecks,
+                executionStatistics,
                 debug: debugInfo,
             };
         }
@@ -95856,7 +95865,7 @@ class CheckExecutionEngine {
         });
     }
     /**
-     * Execute review checks and return grouped results for new architecture
+     * Execute review checks and return grouped results with statistics for new architecture
      */
     async executeGroupedChecks(prInfo, checks, timeout, config, outputFormat, debug, maxParallelism, failFast, tagFilter) {
         // Determine where to send log messages based on output format
@@ -95885,7 +95894,10 @@ class CheckExecutionEngine {
         // Check if we have any checks left after filtering
         if (checks.length === 0) {
             logger_1.logger.warn('⚠️ No checks remain after tag filtering');
-            return {};
+            return {
+                results: {},
+                statistics: this.buildExecutionStatistics(),
+            };
         }
         if (!config?.checks) {
             throw new Error('Config with check definitions required for grouped execution');
@@ -95909,10 +95921,16 @@ class CheckExecutionEngine {
             const checkResult = await this.executeSingleGroupedCheck(prInfo, checks[0], timeout, config, logFn, debug);
             const groupedResults = {};
             groupedResults[checkResult.group] = [checkResult];
-            return groupedResults;
+            return {
+                results: groupedResults,
+                statistics: this.buildExecutionStatistics(),
+            };
         }
         // No checks to execute
-        return {};
+        return {
+            results: {},
+            statistics: this.buildExecutionStatistics(),
+        };
     }
     /**
      * Execute single check and return grouped result
@@ -95957,13 +95975,19 @@ class CheckExecutionEngine {
         };
     }
     /**
-     * Execute multiple checks with dependency awareness - return grouped results
+     * Execute multiple checks with dependency awareness - return grouped results with statistics
      */
     async executeGroupedDependencyAwareChecks(prInfo, checks, timeout, config, logFn, debug, maxParallelism, failFast) {
         // Use the existing dependency-aware execution logic
         const reviewSummary = await this.executeDependencyAwareChecks(prInfo, checks, timeout, config, logFn, debug, maxParallelism, failFast);
+        // Build execution statistics
+        const executionStatistics = this.buildExecutionStatistics();
         // Convert the flat ReviewSummary to grouped CheckResults
-        return await this.convertReviewSummaryToGroupedResults(reviewSummary, checks, config, prInfo);
+        const groupedResults = await this.convertReviewSummaryToGroupedResults(reviewSummary, checks, config, prInfo);
+        return {
+            results: groupedResults,
+            statistics: executionStatistics,
+        };
     }
     /**
      * Convert ReviewSummary to GroupedCheckResults
@@ -96276,9 +96300,10 @@ class CheckExecutionEngine {
         let shouldStopExecution = false;
         let completedChecksCount = 0;
         const totalChecksCount = stats.totalChecks;
-        let skippedChecksCount = 0;
-        let failedChecksCount = 0;
-        const executionStartTime = Date.now();
+        // Initialize execution statistics for all checks
+        for (const checkName of checks) {
+            this.initializeCheckStats(checkName);
+        }
         for (let levelIndex = 0; levelIndex < dependencyGraph.executionOrder.length && !shouldStopExecution; levelIndex++) {
             const executionGroup = dependencyGraph.executionOrder[levelIndex];
             // Check if any checks in this level require session reuse - if so, force sequential execution
@@ -96411,9 +96436,13 @@ class CheckExecutionEngine {
                     // Handle forEach dependent execution
                     let finalResult;
                     if (isForEachDependent && forEachParentName) {
+                        // Record forEach preview items
+                        this.recordForEachPreview(checkName, forEachItems);
                         if (debug) {
                             log(`🔄 Debug: Check "${checkName}" depends on forEach check "${forEachParentName}", executing ${forEachItems.length} times`);
                         }
+                        // Log forEach processing start
+                        logger_1.logger.info(`  Processing ${forEachItems.length} items...`);
                         const allIssues = [];
                         const allOutputs = [];
                         const aggregatedContents = [];
@@ -96474,6 +96503,8 @@ class CheckExecutionEngine {
                             if (debug) {
                                 log(`🔄 Debug: Executing check "${checkName}" for item ${itemIndex + 1}/${forEachItems.length}`);
                             }
+                            // Track iteration start
+                            const iterationStart = this.recordIterationStart(checkName);
                             // Execute with retry/routing semantics per item
                             const itemResult = await this.executeWithRouting(checkName, checkConfig, provider, providerConfig, prInfo, forEachDependencyResults, sessionInfo, config, dependencyGraph, debug, results, 
                             /*foreachContext*/ {
@@ -96481,6 +96512,11 @@ class CheckExecutionEngine {
                                 total: forEachItems.length,
                                 parent: forEachParentName,
                             });
+                            // Record iteration completion
+                            const iterationDuration = (Date.now() - iterationStart) / 1000;
+                            this.recordIterationComplete(checkName, iterationStart, true, itemResult.issues || [], itemResult.output);
+                            // Log iteration progress
+                            logger_1.logger.info(`  ✔ ${itemIndex + 1}/${forEachItems.length} (${iterationDuration.toFixed(1)}s)`);
                             return { index: itemIndex, itemResult };
                         });
                         const forEachConcurrency = Math.max(1, Math.min(forEachItems.length, effectiveMaxParallelism));
@@ -96532,8 +96568,9 @@ class CheckExecutionEngine {
                         if (checkConfig.if) {
                             const shouldRun = await this.evaluateCheckCondition(checkName, checkConfig.if, prInfo, results, debug);
                             if (!shouldRun) {
-                                skippedChecksCount++;
-                                logger_1.logger.info(`⏭  Skipping check: ${checkName} (if condition evaluated to false)`);
+                                // Record skip with condition
+                                this.recordSkip(checkName, 'if_condition', checkConfig.if);
+                                logger_1.logger.info(`⏭  Skipped (if: ${this.truncate(checkConfig.if, 40)})`);
                                 return {
                                     checkName,
                                     error: null,
@@ -96546,6 +96583,8 @@ class CheckExecutionEngine {
                         }
                         // Execute with retry/routing semantics
                         finalResult = await this.executeWithRouting(checkName, checkConfig, provider, providerConfig, prInfo, dependencyResults, sessionInfo, config, dependencyGraph, debug, results);
+                        // Record normal (non-forEach) execution
+                        this.recordIterationComplete(checkName, checkStartTime, true, finalResult.issues || [], finalResult.output);
                         if (checkConfig.forEach) {
                             try {
                                 const finalResultWithOutput = finalResult;
@@ -96576,7 +96615,20 @@ class CheckExecutionEngine {
                     };
                     const checkDuration = ((Date.now() - checkStartTime) / 1000).toFixed(1);
                     const issueCount = enrichedIssues.length;
-                    if (issueCount > 0) {
+                    const checkStats = this.executionStats.get(checkName);
+                    // Enhanced completion message with forEach stats
+                    if (checkStats && checkStats.totalRuns > 1) {
+                        if (issueCount > 0) {
+                            logger_1.logger.success(`Check complete: ${checkName} (${checkDuration}s) - ${checkStats.totalRuns} runs, ${issueCount} issue${issueCount === 1 ? '' : 's'}`);
+                        }
+                        else {
+                            logger_1.logger.success(`Check complete: ${checkName} (${checkDuration}s) - ${checkStats.totalRuns} runs`);
+                        }
+                    }
+                    else if (checkStats && checkStats.outputsProduced && checkStats.outputsProduced > 0) {
+                        logger_1.logger.success(`Check complete: ${checkName} (${checkDuration}s) - ${checkStats.outputsProduced} items`);
+                    }
+                    else if (issueCount > 0) {
                         logger_1.logger.success(`Check complete: ${checkName} (${checkDuration}s) - ${issueCount} issue${issueCount === 1 ? '' : 's'} found`);
                     }
                     else {
@@ -96589,9 +96641,11 @@ class CheckExecutionEngine {
                     };
                 }
                 catch (error) {
-                    failedChecksCount++;
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     const checkDuration = ((Date.now() - checkStartTime) / 1000).toFixed(1);
+                    // Record error in stats
+                    this.recordError(checkName, error instanceof Error ? error : new Error(String(error)));
+                    this.recordIterationComplete(checkName, checkStartTime, false, [], undefined);
                     logger_1.logger.error(`✖ Check failed: ${checkName} (${checkDuration}s) - ${errorMessage}`);
                     if (debug) {
                         log(`🔧 Debug: Error in check ${checkName}: ${errorMessage}`);
@@ -96709,20 +96763,18 @@ class CheckExecutionEngine {
                 }
             }
         }
-        // Log final execution summary
-        const executionDuration = ((Date.now() - executionStartTime) / 1000).toFixed(1);
-        const successfulChecks = totalChecksCount - failedChecksCount - skippedChecksCount;
-        logger_1.logger.info('');
-        logger_1.logger.step(`Execution complete (${executionDuration}s)`);
-        logger_1.logger.info(`  ✔ Successful: ${successfulChecks}/${totalChecksCount}`);
-        if (skippedChecksCount > 0) {
-            logger_1.logger.info(`  ⏭  Skipped: ${skippedChecksCount}`);
-        }
-        if (failedChecksCount > 0) {
-            logger_1.logger.info(`  ✖ Failed: ${failedChecksCount}`);
+        // Build and log final execution summary
+        const executionStatistics = this.buildExecutionStatistics();
+        // Show detailed summary table (only if logFn outputs to console)
+        // Skip when output format is JSON/SARIF to avoid polluting structured output
+        // Check if logFn is console.log (not a no-op or console.error)
+        if (logFn === console.log) {
+            this.logExecutionSummary(executionStatistics);
         }
+        // Add warning if execution stopped early
         if (shouldStopExecution) {
-            logger_1.logger.warn(`  ⚠️  Execution stopped early due to fail-fast`);
+            logger_1.logger.info('');
+            logger_1.logger.warn(`⚠️  Execution stopped early due to fail-fast`);
         }
         if (debug) {
             if (shouldStopExecution) {
@@ -97661,6 +97713,251 @@ class CheckExecutionEngine {
         // events, which don't generate PRInfo objects in the first place.
         return 'pr_updated';
     }
+    /**
+     * Initialize execution statistics for a check
+     */
+    initializeCheckStats(checkName) {
+        this.executionStats.set(checkName, {
+            checkName,
+            totalRuns: 0,
+            successfulRuns: 0,
+            failedRuns: 0,
+            skipped: false,
+            totalDuration: 0,
+            issuesFound: 0,
+            issuesBySeverity: {
+                critical: 0,
+                error: 0,
+                warning: 0,
+                info: 0,
+            },
+            perIterationDuration: [],
+        });
+    }
+    /**
+     * Record the start of a check iteration
+     * Returns the start timestamp for duration tracking
+     */
+    recordIterationStart(_checkName) {
+        return Date.now();
+    }
+    /**
+     * Record completion of a check iteration
+     */
+    recordIterationComplete(checkName, startTime, success, issues, output) {
+        const stats = this.executionStats.get(checkName);
+        if (!stats)
+            return;
+        const duration = Date.now() - startTime;
+        stats.totalRuns++;
+        if (success) {
+            stats.successfulRuns++;
+        }
+        else {
+            stats.failedRuns++;
+        }
+        stats.totalDuration += duration;
+        stats.perIterationDuration.push(duration);
+        // Count issues by severity
+        for (const issue of issues) {
+            stats.issuesFound++;
+            if (issue.severity === 'critical')
+                stats.issuesBySeverity.critical++;
+            else if (issue.severity === 'error')
+                stats.issuesBySeverity.error++;
+            else if (issue.severity === 'warning')
+                stats.issuesBySeverity.warning++;
+            else if (issue.severity === 'info')
+                stats.issuesBySeverity.info++;
+        }
+        // Track outputs produced
+        if (output !== undefined) {
+            stats.outputsProduced = (stats.outputsProduced || 0) + 1;
+        }
+    }
+    /**
+     * Record that a check was skipped
+     */
+    recordSkip(checkName, reason, condition) {
+        const stats = this.executionStats.get(checkName);
+        if (!stats)
+            return;
+        stats.skipped = true;
+        stats.skipReason = reason;
+        if (condition) {
+            stats.skipCondition = condition;
+        }
+    }
+    /**
+     * Record forEach preview items
+     */
+    recordForEachPreview(checkName, items) {
+        const stats = this.executionStats.get(checkName);
+        if (!stats || !items.length)
+            return;
+        // Store preview of first 3 items
+        const preview = items.slice(0, 3).map(item => {
+            const str = typeof item === 'string' ? item : JSON.stringify(item);
+            return str.length > 50 ? str.substring(0, 47) + '...' : str;
+        });
+        if (items.length > 3) {
+            preview.push(`...${items.length - 3} more`);
+        }
+        stats.forEachPreview = preview;
+    }
+    /**
+     * Record an error for a check
+     */
+    recordError(checkName, error) {
+        const stats = this.executionStats.get(checkName);
+        if (!stats)
+            return;
+        stats.errorMessage = error instanceof Error ? error.message : String(error);
+    }
+    /**
+     * Build the final execution statistics object
+     */
+    buildExecutionStatistics() {
+        const checks = Array.from(this.executionStats.values());
+        const totalExecutions = checks.reduce((sum, s) => sum + s.totalRuns, 0);
+        const successfulExecutions = checks.reduce((sum, s) => sum + s.successfulRuns, 0);
+        const failedExecutions = checks.reduce((sum, s) => sum + s.failedRuns, 0);
+        const skippedChecks = checks.filter(s => s.skipped).length;
+        const totalDuration = checks.reduce((sum, s) => sum + s.totalDuration, 0);
+        return {
+            totalChecksConfigured: checks.length,
+            totalExecutions,
+            successfulExecutions,
+            failedExecutions,
+            skippedChecks,
+            totalDuration,
+            checks,
+        };
+    }
+    /**
+     * Truncate a string to max length with ellipsis
+     */
+    truncate(str, maxLen) {
+        if (str.length <= maxLen)
+            return str;
+        return str.substring(0, maxLen - 3) + '...';
+    }
+    /**
+     * Format the Status column for execution summary table
+     */
+    formatStatusColumn(stats) {
+        if (stats.skipped) {
+            if (stats.skipReason === 'if_condition')
+                return '⏭ if';
+            if (stats.skipReason === 'fail_fast')
+                return '⏭ ff';
+            if (stats.skipReason === 'dependency_failed')
+                return '⏭ dep';
+            return '⏭';
+        }
+        if (stats.totalRuns === 0)
+            return '-';
+        const symbol = stats.failedRuns === 0 ? '✔' : stats.successfulRuns === 0 ? '✖' : '✔/✖';
+        // Show iteration count if > 1
+        if (stats.totalRuns > 1) {
+            if (stats.failedRuns > 0 && stats.successfulRuns > 0) {
+                // Partial success
+                return `${symbol} ${stats.successfulRuns}/${stats.totalRuns}`;
+            }
+            else {
+                // All success or all failed
+                return `${symbol} ×${stats.totalRuns}`;
+            }
+        }
+        return symbol;
+    }
+    /**
+     * Format the Details column for execution summary table
+     */
+    formatDetailsColumn(stats) {
+        const parts = [];
+        // Outputs produced (forEach)
+        if (stats.outputsProduced && stats.outputsProduced > 0) {
+            parts.push(`→${stats.outputsProduced}`);
+        }
+        // Critical issues
+        if (stats.issuesBySeverity.critical > 0) {
+            parts.push(`${stats.issuesBySeverity.critical}🔴`);
+        }
+        // Warnings
+        if (stats.issuesBySeverity.warning > 0) {
+            parts.push(`${stats.issuesBySeverity.warning}⚠️`);
+        }
+        // Info (only if no critical/warnings)
+        if (stats.issuesBySeverity.info > 0 &&
+            stats.issuesBySeverity.critical === 0 &&
+            stats.issuesBySeverity.warning === 0) {
+            parts.push(`${stats.issuesBySeverity.info}💡`);
+        }
+        // Error message or skip condition
+        if (stats.errorMessage) {
+            parts.push(this.truncate(stats.errorMessage, 20));
+        }
+        else if (stats.skipCondition) {
+            parts.push(this.truncate(stats.skipCondition, 20));
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Log the execution summary table
+     */
+    logExecutionSummary(stats) {
+        const totalIssues = stats.checks.reduce((sum, s) => sum + s.issuesFound, 0);
+        const criticalIssues = stats.checks.reduce((sum, s) => sum + s.issuesBySeverity.critical, 0);
+        const warningIssues = stats.checks.reduce((sum, s) => sum + s.issuesBySeverity.warning, 0);
+        const durationSec = (stats.totalDuration / 1000).toFixed(1);
+        // Summary box
+        const summaryTable = new (__nccwpck_require__(25832))({
+            style: {
+                head: [],
+                border: [],
+            },
+            colWidths: [41],
+        });
+        summaryTable.push([`Execution Complete (${durationSec}s)`], [`Checks: ${stats.totalChecksConfigured} configured → ${stats.totalExecutions} executions`], [
+            `Status: ${stats.successfulExecutions} ✔ │ ${stats.failedExecutions} ✖ │ ${stats.skippedChecks} ⏭`,
+        ]);
+        if (totalIssues > 0) {
+            let issuesLine = `Issues: ${totalIssues} total`;
+            if (criticalIssues > 0)
+                issuesLine += ` (${criticalIssues} 🔴`;
+            if (warningIssues > 0)
+                issuesLine += `${criticalIssues > 0 ? ' ' : ' ('}${warningIssues} ⚠️)`;
+            else if (criticalIssues > 0)
+                issuesLine += ')';
+            summaryTable.push([issuesLine]);
+        }
+        logger_1.logger.info('');
+        logger_1.logger.info(summaryTable.toString());
+        // Details table
+        logger_1.logger.info('');
+        logger_1.logger.info('Check Details:');
+        const detailsTable = new (__nccwpck_require__(25832))({
+            head: ['Check', 'Duration', 'Status', 'Details'],
+            colWidths: [21, 10, 10, 21],
+            style: {
+                head: ['cyan'],
+                border: ['grey'],
+            },
+        });
+        for (const checkStats of stats.checks) {
+            const duration = checkStats.skipped
+                ? '-'
+                : `${(checkStats.totalDuration / 1000).toFixed(1)}s`;
+            const status = this.formatStatusColumn(checkStats);
+            const details = this.formatDetailsColumn(checkStats);
+            detailsTable.push([checkStats.checkName, duration, status, details]);
+        }
+        logger_1.logger.info(detailsTable.toString());
+        // Legend
+        logger_1.logger.info('');
+        logger_1.logger.info('Legend: ✔=success │ ✖=failed │ ⏭=skipped │ ×N=iterations │ →N=outputs │ N🔴=critical │ N⚠️=warnings');
+    }
 }
 exports.CheckExecutionEngine = CheckExecutionEngine;
 
@@ -97747,7 +98044,15 @@ async function main() {
             console.log(cli.getVersion());
             process.exit(0);
         }
+        // Configure logger based on output format and verbosity
+        logger_1.logger.configure({
+            outputFormat: options.output,
+            debug: options.debug,
+            verbose: options.verbose,
+            quiet: options.quiet,
+        });
         // Print runtime banner (info level): Visor + Probe versions
+        // Banner is automatically suppressed for JSON/SARIF by logger configuration
         try {
             const visorVersion = process.env.VISOR_VERSION || ((__nccwpck_require__(8330)/* .version */ .rE) ?? 'dev');
             let probeVersion = process.env.PROBE_VERSION || 'unknown';
@@ -97915,7 +98220,9 @@ async function main() {
         const prInfoWithContext = prInfo;
         prInfoWithContext.includeCodeContext = includeCodeContext;
         // Execute checks with proper parameters
-        const groupedResults = await engine.executeGroupedChecks(prInfo, checksToRun, options.timeout, config, options.output, options.debug || false, options.maxParallelism, options.failFast, tagFilter);
+        const executionResult = await engine.executeGroupedChecks(prInfo, checksToRun, options.timeout, config, options.output, options.debug || false, options.maxParallelism, options.failFast, tagFilter);
+        // Extract results and statistics from the execution result
+        const { results: groupedResults, statistics: executionStatistics } = executionResult;
         const shouldFilterResults = explicitChecks && explicitChecks.size > 0 && !explicitChecks.has('all');
         const groupedResultsToUse = shouldFilterResults
             ? Object.fromEntries(Object.entries(groupedResults)
@@ -97940,7 +98247,8 @@ async function main() {
                 }
             }
         }
-        const executedCheckNames = Array.from(new Set(Object.values(groupedResultsToUse).flatMap((checks) => checks.map(check => check.checkName))));
+        // Get executed check names
+        const executedCheckNames = Array.from(new Set(Object.entries(groupedResultsToUse).flatMap(([, checks]) => checks.map(check => check.checkName))));
         // Format output based on format type
         logger_1.logger.step(`Formatting results as ${options.output}`);
         let output;
@@ -97953,12 +98261,14 @@ async function main() {
                 repositoryInfo,
                 reviewSummary: {
                     issues: Object.values(groupedResultsToUse)
-                        .flatMap((r) => r.map((check) => check.issues || []).flat())
+                        .flatMap(checks => checks.flatMap(check => check.issues || []))
                         .flat(),
                 },
                 executionTime: 0,
                 timestamp: new Date().toISOString(),
                 checksExecuted: executedCheckNames,
+                executionStatistics,
+                isCodeReview: includeCodeContext,
             };
             output = output_formatters_1.OutputFormatters.formatAsSarif(analysisResult);
         }
@@ -97968,12 +98278,14 @@ async function main() {
                 repositoryInfo,
                 reviewSummary: {
                     issues: Object.values(groupedResultsToUse)
-                        .flatMap((r) => r.map((check) => check.issues || []).flat())
+                        .flatMap(checks => checks.flatMap(check => check.issues || []))
                         .flat(),
                 },
                 executionTime: 0,
                 timestamp: new Date().toISOString(),
                 checksExecuted: executedCheckNames,
+                executionStatistics,
+                isCodeReview: includeCodeContext,
             };
             output = output_formatters_1.OutputFormatters.formatAsMarkdown(analysisResult);
         }
@@ -97983,12 +98295,14 @@ async function main() {
                 repositoryInfo,
                 reviewSummary: {
                     issues: Object.values(groupedResultsToUse)
-                        .flatMap((r) => r.map((check) => check.issues || []).flat())
+                        .flatMap(checks => checks.flatMap(check => check.issues || []))
                         .flat(),
                 },
                 executionTime: 0,
                 timestamp: new Date().toISOString(),
                 checksExecuted: executedCheckNames,
+                executionStatistics,
+                isCodeReview: includeCodeContext,
             };
             output = output_formatters_1.OutputFormatters.formatAsTable(analysisResult, { showDetails: true });
         }
@@ -98009,7 +98323,7 @@ async function main() {
             console.log(output);
         }
         // Summarize execution (stderr only; suppressed in JSON/SARIF unless verbose/debug)
-        const allResults = Object.values(groupedResultsToUse).flat();
+        const allResults = Object.values(groupedResultsToUse).flatMap(checks => checks);
         const allIssues = allResults.flatMap((r) => r.issues || []);
         const counts = allIssues.reduce((acc, issue) => {
             const sev = (issue.severity || 'info').toLowerCase();
@@ -101532,14 +101846,15 @@ async function handleIssueEvent(octokit, owner, repo, context, inputs, config, c
     const { CheckExecutionEngine } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(80299)));
     const engine = new CheckExecutionEngine();
     try {
-        const result = await engine.executeGroupedChecks(prInfo, checksToRun, undefined, // timeout
+        const executionResult = await engine.executeGroupedChecks(prInfo, checksToRun, undefined, // timeout
         config, undefined, // outputFormat
         inputs.debug === 'true');
+        const { results } = executionResult;
         // Format and post results as a comment on the issue
-        if (Object.keys(result).length > 0) {
+        if (Object.keys(results).length > 0) {
             let commentBody = '';
             // Directly use check content without adding extra headers
-            for (const checks of Object.values(result)) {
+            for (const checks of Object.values(results)) {
                 for (const check of checks) {
                     if (check.content && check.content.trim()) {
                         commentBody += `${check.content}\n\n`;
@@ -101798,7 +102113,7 @@ async function handleIssueComment(octokit, owner, repo, context, inputs, actionC
                     console.log('📝 Skipping comment (comment-on-pr is disabled)');
                 }
                 // Calculate total check results from grouped results
-                const totalChecks = Object.values(groupedResults).flat().length;
+                const totalChecks = Object.values(groupedResults).flatMap(checks => checks).length;
                 (0, core_1.setOutput)('checks-executed', totalChecks.toString());
             }
             break;
@@ -102118,7 +102433,7 @@ async function completeGitHubChecks(octokit, owner, repo, checkRunMap, groupedRe
  */
 function extractIssuesFromGroupedResults(groupedResults) {
     const issues = [];
-    for (const [groupName, checkResults] of Object.entries(groupedResults)) {
+    for (const checkResults of Object.values(groupedResults)) {
         for (const checkResult of checkResults) {
             const { checkName, content } = checkResult;
             // First, check if structured issues are available
@@ -102147,7 +102462,7 @@ function extractIssuesFromGroupedResults(groupedResults) {
                     message: message.trim(),
                     severity,
                     category: 'logic', // Default category since we can't parse this from content
-                    group: groupName,
+                    group: checkResult.group,
                     timestamp: Date.now(),
                 };
                 issues.push(issue);
@@ -102711,19 +103026,35 @@ class OutputFormatters {
         const issues = result.reviewSummary.issues || [];
         const totalIssues = issues.length;
         const criticalIssues = issues.filter(i => i.severity === 'critical').length;
-        // Summary table
-        const summaryTable = new cli_table3_1.default({
-            head: ['Metric', 'Value'],
-            colWidths: [25, 30],
-            style: {
-                head: ['cyan', 'bold'],
-                border: ['grey'],
-            },
-        });
-        summaryTable.push(['Total Issues', totalIssues.toString()], ['Critical Issues', criticalIssues.toString()], ['Files Analyzed', result.repositoryInfo.files.length.toString()], ['Total Additions', result.repositoryInfo.totalAdditions.toString()], ['Total Deletions', result.repositoryInfo.totalDeletions.toString()], ['Execution Time', `${result.executionTime}ms`], ['Checks Executed', result.checksExecuted.join(', ')]);
-        output += 'Analysis Summary\n';
-        output += summaryTable.toString() + '\n';
-        output += '\n';
+        // Check if this is a code review context
+        const isCodeReview = result.isCodeReview || issues.some(i => i.schema === 'code-review');
+        // Only show "Analysis Summary" table for code review contexts or when there are issues
+        // For other contexts, the execution statistics table already provides summary
+        if (isCodeReview || totalIssues > 0) {
+            // Summary table
+            const summaryTable = new cli_table3_1.default({
+                head: ['Metric', 'Value'],
+                colWidths: [25, 30],
+                style: {
+                    head: ['cyan', 'bold'],
+                    border: ['grey'],
+                },
+            });
+            // Add issue metrics
+            summaryTable.push(['Total Issues', totalIssues.toString()]);
+            if (criticalIssues > 0) {
+                summaryTable.push(['Critical Issues', criticalIssues.toString()]);
+            }
+            // Add code-review specific metrics if in code review context
+            if (isCodeReview && result.repositoryInfo.files.length > 0) {
+                summaryTable.push(['Files Analyzed', result.repositoryInfo.files.length.toString()], ['Total Additions', result.repositoryInfo.totalAdditions.toString()], ['Total Deletions', result.repositoryInfo.totalDeletions.toString()]);
+            }
+            // Always show execution time and checks executed
+            summaryTable.push(['Execution Time', `${result.executionTime}ms`], ['Checks Executed', result.checksExecuted.join(', ')]);
+            output += 'Analysis Summary\n';
+            output += summaryTable.toString() + '\n';
+            output += '\n';
+        }
         // Issues by category table
         if (issues.length > 0) {
             if (groupByCategory) {
@@ -103963,13 +104294,13 @@ class AICheckProvider extends check_provider_interface_1.CheckProvider {
         }
         // Setup MCP tools if any servers are configured
         if (Object.keys(mcpServers).length > 0) {
+            // Pass raw server config to AI service so it can enable MCP in ProbeAgent
+            aiConfig.mcpServers = mcpServers;
+            // Optional: attempt to enumerate tools for debug visibility (not required for functionality)
             const mcpConfig = { mcpServers };
             const mcpTools = await this.setupMcpTools(mcpConfig);
-            if (mcpTools.length > 0) {
-                aiConfig.tools = mcpTools;
-                if (aiConfig.debug) {
-                    console.error(`🔧 Debug: AI check configured with ${mcpTools.length} MCP tools from ${Object.keys(mcpServers).length} servers`);
-                }
+            if (aiConfig.debug) {
+                console.error(`🔧 Debug: AI check MCP configured with ${Object.keys(mcpServers).length} servers; discovered ${mcpTools.length} tools`);
             }
         }
         // Process prompt with Liquid templates and file loading
@@ -106558,8 +106889,8 @@ class PRReviewer {
         if (config && checks && checks.length > 0) {
             const { CheckExecutionEngine } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(80299)));
             const engine = new CheckExecutionEngine();
-            const groupedResults = await engine.executeGroupedChecks(prInfo, checks, undefined, config, undefined, debug);
-            return groupedResults;
+            const { results } = await engine.executeGroupedChecks(prInfo, checks, undefined, config, undefined, debug);
+            return results;
         }
         throw new Error('No configuration provided. Please create a .visor.yaml file with check definitions. ' +
             'Built-in prompts have been removed - all checks must be explicitly configured.');
@@ -156729,14 +157060,53 @@ var init_probeTool = __esm({
         if (!targetDir.startsWith(secureBaseDir + import_path7.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 listFilesByLevel({
-            directory: targetDir,
-            maxFiles: 100,
-            respectGitignore: !process.env.PROBE_NO_GITIGNORE || process.env.PROBE_NO_GITIGNORE === "",
-            cwd: secureBaseDir
+          const files = await import_fs4.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_path7.default.join(targetDir, file.name);
+            let size = 0;
+            try {
+              const stats = await import_fs4.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);
           });
-          return files;
+          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}`);
         }
@@ -156754,6 +157124,9 @@ var init_probeTool = __esm({
         if (!targetDir.startsWith(secureBaseDir + import_path7.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,
@@ -156763,7 +157136,17 @@ var init_probeTool = __esm({
           if (!recursive) {
             options.deep = 1;
           }
-          const files = await (0, import_glob.glob)(pattern, options);
+          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}`);
@@ -168081,13 +168464,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",
@@ -168228,6 +168612,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 "...")
@@ -168311,6 +168697,8 @@ var init_lexer2 = __esm({
       DiamondClose,
       AngleOpen,
       AngleLess,
+      ForwardSlash,
+      Backslash,
       Pipe,
       TripleColon,
       Ampersand,
@@ -168503,6 +168891,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
@@ -169551,6 +169941,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" },
@@ -170450,9 +170900,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([
@@ -172003,6 +172459,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);
@@ -172283,8 +172802,543 @@ 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"() {
+    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;
+      }
+    };
   }
 });
 
@@ -179967,16 +181021,2435 @@ var require_dagre = __commonJS({
 });
 
 // node_modules/@probelabs/maid/out/renderer/layout.js
-var import_dagre;
+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) });
+      }
+    }
+    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/@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;
+    }
+  }
+  if (themeUnderConfig && Object.keys(themeVars).length) {
+    ensure(config, "themeVariables", {});
+    Object.assign(config.themeVariables, themeVars);
+  }
+  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);
+  }
+  return v3;
+}
+function setKV(target, key, rawValue) {
+  const v3 = unquote2(rawValue);
+  if (v3 === "") {
+    target[key] = "";
+    return;
+  }
+  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"() {
   }
 });
 
@@ -179987,6 +183460,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();
@@ -179994,9 +183563,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();
   }
 });
 
@@ -180030,6 +183834,7 @@ var init_out = __esm({
     init_edits();
     init_fixes();
     init_renderer();
+    init_mermaid_compat();
     init_router();
     init_fixes();
     init_edits();
@@ -180745,8 +184550,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
           });
@@ -181646,6 +185451,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
@@ -182416,12 +186233,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}
@@ -182429,7 +186262,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>` });
@@ -182441,6 +186280,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,
@@ -182482,6 +186333,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,
@@ -182490,6 +186350,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,
@@ -182539,6 +186406,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) {
@@ -183252,12 +187129,14 @@ __export(index_exports, {
   getBinaryPath: () => getBinaryPath,
   initializeSimpleTelemetryFromOptions: () => initializeSimpleTelemetryFromOptions,
   listFilesByLevel: () => listFilesByLevel,
+  listFilesToolInstance: () => listFilesToolInstance,
   parseXmlToolCall: () => parseXmlToolCall,
   query: () => query,
   querySchema: () => querySchema,
   queryTool: () => queryTool,
   queryToolDefinition: () => queryToolDefinition,
   search: () => search,
+  searchFilesToolInstance: () => searchFilesToolInstance,
   searchSchema: () => searchSchema,
   searchTool: () => searchTool,
   searchToolDefinition: () => searchToolDefinition,
@@ -183280,6 +187159,7 @@ var init_index = __esm({
     init_bash();
     init_ProbeAgent();
     init_simpleTelemetry();
+    init_probeTool();
   }
 });
 init_index();
@@ -213361,7 +217241,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"application/1d-interleaved-parityfec
 /***/ ((module) => {
 
 "use strict";
-module.exports = {"rE":"0.1.71"};
+module.exports = {"rE":"0.1.73"};
 
 /***/ })