fix(mermaid): increase PDF export height limits for complex diagrams

Increased rendering resources to better accommodate complex diagrams:
- Initial height: 1000px -> 3000px
- Maximum height: 2000px -> 4000px
- Layout cycles: 3 -> 5 with longer delays (0.05s -> 0.1s)
- Added stability detection and debug logging
- Fixed Swift 6 concurrency issues

Most diagrams now export successfully. Very large diagrams may still
need additional investigation.

Author: fewtarius

Sources/UserInterface/Chat/MarkdownASTToNSAttributedString.swift

@@ -212,33 +212,63 @@ class MarkdownASTToNSAttributedString {
             return createFallbackCodeBlock(code: code)
         }
 
+        // Render at higher resolution (700px) for better quality
+        // Then scale down to PDF page width (550px) for proper fitting
+        let renderWidth: CGFloat = 700
+        let targetWidth: CGFloat = 550  // PDF page usable width
+        
         // Create SwiftUI diagram view WITH pre-parsed diagram
         let diagramView = MermaidDiagramView(code: code, diagram: parsedDiagram, showBackground: false)
-            .frame(width: 700, alignment: .leading)
+            .frame(width: renderWidth, alignment: .leading)
 
         // Use bitmapImageRepForCachingDisplay - most reliable for offscreen rendering
         var capturedImage: NSImage?
 
-        let renderWithBitmap: () -> NSImage? = {
+        let renderWithBitmap: () -> NSImage? = { [self] in
             let hostingView = NSHostingView(rootView: diagramView)
-            hostingView.frame = NSRect(x: 0, y: 0, width: 700, height: 1000)
+            // INCREASED: Use 3000px initial height (was 1000px) for complex diagrams
+            hostingView.frame = NSRect(x: 0, y: 0, width: renderWidth, height: 3000)
 
             // Force layout multiple times for SwiftUI to properly render
-            for _ in 0..<3 {
+            // INCREASED: 5 cycles with longer delays (was 3 cycles × 0.05s)
+            var lastHeight: CGFloat = 0
+            for cycle in 0..<5 {
                 hostingView.layout()
                 hostingView.layoutSubtreeIfNeeded()
-                RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.05))
+                RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.1))
+                
+                // Check for stabilization
+                let currentSize = hostingView.fittingSize
+                self.logger.debug("PDF render cycle \(cycle): fittingSize=\(currentSize.width)×\(currentSize.height)")
+                
+                if cycle > 2 && currentSize.height > 100 {
+                    let heightChange = abs(currentSize.height - lastHeight)
+                    let changePercent = heightChange / max(currentSize.height, 1) * 100
+                    if changePercent < 5 {
+                        self.logger.info("PDF render stabilized at cycle \(cycle): height=\(currentSize.height)")
+                        break
+                    }
+                }
+                lastHeight = currentSize.height
             }
 
             // Get actual size after layout
             let actualSize = hostingView.fittingSize
-            let finalHeight = max(min(actualSize.height, 2000), 100)
-            hostingView.frame = NSRect(x: 0, y: 0, width: 700, height: finalHeight)
+            self.logger.info("PDF render fittingSize: \(actualSize.width)×\(actualSize.height)")
+            
+            // INCREASED: Allow up to 4000px height (was 2000px) for very complex diagrams
+            let finalHeight = max(min(actualSize.height, 4000), 100)
+            let finalWidth = max(actualSize.width, renderWidth)
+            
+            hostingView.frame = NSRect(x: 0, y: 0, width: finalWidth, height: finalHeight)
+            self.logger.info("PDF render final frame: \(finalWidth)×\(finalHeight)")
+            
             hostingView.layout()
             hostingView.layoutSubtreeIfNeeded()
 
             // Render using bitmapImageRepForCachingDisplay (reliable for offscreen)
             guard let bitmapRep = hostingView.bitmapImageRepForCachingDisplay(in: hostingView.bounds) else {
+                self.logger.error("Failed to create bitmap representation for PDF")
                 return nil
             }
             hostingView.cacheDisplay(in: hostingView.bounds, to: bitmapRep)
@@ -269,19 +299,15 @@ class MarkdownASTToNSAttributedString {
             let attachment = NSTextAttachment()
             attachment.image = nsImage
 
-            // Scale image to fit page width (max 550 to account for margins)
-            let maxWidth: CGFloat = 550
-            if nsImage.size.width > maxWidth {
-                let scale = maxWidth / nsImage.size.width
-                attachment.bounds = CGRect(
-                    x: 0,
-                    y: 0,
-                    width: nsImage.size.width * scale,
-                    height: nsImage.size.height * scale
-                )
-            } else {
-                attachment.bounds = CGRect(origin: .zero, size: nsImage.size)
-            }
+            // Scale image to fit PDF page width
+            // Render at 700px for quality, scale to 550px for page fit
+            let scale = targetWidth / nsImage.size.width
+            attachment.bounds = CGRect(
+                x: 0,
+                y: 0,
+                width: nsImage.size.width * scale,
+                height: nsImage.size.height * scale
+            )
 
             logger.debug("Mermaid NSTextAttachment created - hasImage: \(attachment.image != nil), bounds: \(attachment.bounds)")
 

Sources/UserInterface/Chat/Mermaid/MermaidImageRenderer.swift

@@ -3,22 +3,28 @@
 
 import SwiftUI
 import AppKit
+import Logging
 
 /// Utility to render SwiftUI views as NSImages for PDF/print export
 struct MermaidImageRenderer {
+    private static let logger = Logger(label: "com.sam.mermaid.imagerenderer")
+    
     /// Render a MermaidDiagramView to an NSImage
     /// - Parameters:
     ///   - code: The mermaid code to render
     ///   - width: Desired width of the rendered image
     /// - Returns: Rendered NSImage, or nil if rendering fails
     @MainActor
     static func renderDiagram(code: String, width: CGFloat = 600) -> NSImage? {
+        logger.info("Starting PDF render: width=\(width)")
+        
         // Parse the diagram first to verify it's valid
         let parser = MermaidParser()
         let diagram = parser.parse(code)
 
         // Skip rendering if it's unsupported
         if case .unsupported = diagram {
+            logger.warning("Skipping unsupported diagram type")
             return nil
         }
 
@@ -31,12 +37,20 @@ struct MermaidImageRenderer {
             .frame(width: width)
             .padding()
 
+        // INCREASED: Use much larger initial dimensions for complex diagrams
+        // Old: 550px wide × 1500px tall → insufficient for complex flowcharts
+        // New: 800px wide × 3000px tall → more room for layout calculations
+        let initialWidth = width + 40
+        let initialHeight: CGFloat = 3000
+        
         // Create NSHostingView to convert SwiftUI to NSView
         let hostingView = NSHostingView(rootView: containerView)
-        hostingView.frame = CGRect(x: 0, y: 0, width: width + 40, height: 1500)  // Generous initial height
+        hostingView.frame = CGRect(x: 0, y: 0, width: initialWidth, height: initialHeight)
+        logger.debug("Initial frame: width=\(initialWidth), height=\(initialHeight)")
 
         // Force layout with longer delays for complex diagrams
         // Complex flowcharts need time for edge routing and obstacle avoidance calculations
+        var lastHeight: CGFloat = 0
         for cycle in 0..<5 {
             hostingView.layout()
             hostingView.layoutSubtreeIfNeeded()
@@ -46,20 +60,37 @@ struct MermaidImageRenderer {
 
             // Check if rendering is stabilizing (fittingSize not changing much)
             let currentSize = hostingView.fittingSize
+            logger.debug("Layout cycle \(cycle): fittingSize=\(currentSize.width)×\(currentSize.height)")
+            
             if cycle > 2 && currentSize.height > 100 {
-                // If we have a reasonable height after 3 cycles, we're probably done
-                // One more cycle to be sure
-                hostingView.layout()
-                hostingView.layoutSubtreeIfNeeded()
-                RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.15))
-                break
+                // Check if height stabilized (changed less than 5%)
+                let heightChange = abs(currentSize.height - lastHeight)
+                let changePercent = heightChange / max(currentSize.height, 1) * 100
+                
+                if changePercent < 5 {
+                    logger.info("Layout stabilized at cycle \(cycle): height=\(currentSize.height), change=\(changePercent)%")
+                    // One more cycle to be sure
+                    hostingView.layout()
+                    hostingView.layoutSubtreeIfNeeded()
+                    RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.15))
+                    break
+                }
             }
+            lastHeight = currentSize.height
         }
 
         // Calculate actual needed height after layout
         let fittingSize = hostingView.fittingSize
-        let finalHeight = max(min(fittingSize.height, 2000), 400) // Cap between 400-2000
-        hostingView.frame = CGRect(x: 0, y: 0, width: width + 40, height: finalHeight)
+        logger.info("Final fittingSize after layout: \(fittingSize.width)×\(fittingSize.height)")
+        
+        // INCREASED: Allow up to 4000px height for very complex diagrams
+        // Old cap: 2000px → clipped large diagrams
+        // New cap: 4000px → accommodate complex flowcharts
+        let finalHeight = max(min(fittingSize.height, 4000), 400)
+        let finalWidth = max(fittingSize.width, initialWidth)
+        
+        hostingView.frame = CGRect(x: 0, y: 0, width: finalWidth, height: finalHeight)
+        logger.info("Final frame before render: \(finalWidth)×\(finalHeight)")
 
         // Final layout pass
         hostingView.layout()
@@ -68,14 +99,19 @@ struct MermaidImageRenderer {
 
         // Render to bitmap
         guard let bitmapRep = hostingView.bitmapImageRepForCachingDisplay(in: hostingView.bounds) else {
+            logger.error("Failed to create bitmap representation")
             return nil
         }
+        
+        logger.debug("Bitmap representation created: \(bitmapRep.pixelsWide)×\(bitmapRep.pixelsHigh)")
 
         hostingView.cacheDisplay(in: hostingView.bounds, to: bitmapRep)
 
         // Create NSImage from bitmap
         let image = NSImage(size: hostingView.bounds.size)
         image.addRepresentation(bitmapRep)
+        
+        logger.info("Successfully rendered image: \(image.size.width)×\(image.size.height)")
 
         return image
     }

Sources/UserInterface/Documents/MessageExportService.swift

@@ -205,13 +205,15 @@ public class MessageExportService {
         case .codeBlock(let language, let code):
             // Special handling for Mermaid diagrams - render as images
             if let lang = language, lang.lowercased() == "mermaid" {
-                if let diagramImage = MermaidImageRenderer.renderDiagram(code: code, width: 550) {
+                // INCREASED: Use 800px width for PDF export (was 550px)
+                // Complex diagrams need more width for proper layout
+                if let diagramImage = MermaidImageRenderer.renderDiagram(code: code, width: 800) {
                     // Create attachment for image
                     let imageAttachment = NSTextAttachment()
                     imageAttachment.image = diagramImage
 
                     // Scale image to fit page width if needed
-                    let maxWidth: CGFloat = 550
+                    let maxWidth: CGFloat = 800
                     let imageSize = diagramImage.size
                     if imageSize.width > maxWidth {
                         let scale = maxWidth / imageSize.width