Merge remote-tracking branch 'origin/main' into copilot/add-parse-render-rect-blocks

# Conflicts:
#	tests/DiagramForge.Tests/Parsers/Mermaid/MermaidSequenceParserTests.cs

Co-authored-by: jongalloway <68539+jongalloway@users.noreply.github.com>

Author: Copilot

src/DiagramForge/Layout/DefaultLayoutEngine.Sequence.cs

@@ -9,6 +9,16 @@ public sealed partial class DefaultLayoutEngine
     // renderer always reads the same value that the canvas-width calculation uses.
     private const double SelfMessageLoopWidth = 40;
 
+    // Extra horizontal space reserved on the left when autonumber is active so that
+    // the numbered circle badge fits between the canvas edge and the first lifeline.
+    private const double SequenceAutonumberBadgeExtraLeft = 36;
+
+    // Multiplier applied to ShadowBlur when deriving additional autonumber left clearance.
+    // A Gaussian blur of stdDeviation σ is visually significant within ~2σ from the source
+    // edge, so multiplying ShadowBlur by 2 gives a conservative estimate of how far the
+    // filter region extends beyond the node boundary.
+    private const double SequenceAutonumberShadowClearanceMultiplier = 2.0;
+
     private static void LayoutSequenceDiagram(
         Diagram diagram,
         Theme theme,
@@ -31,7 +41,15 @@ private static void LayoutSequenceDiagram(
         // Reserve vertical space for the title and/or subtitle so they don't overlap participants.
         double headingOffset = ComputeHeadingOffset(diagram, theme);
 
-        double runX = pad;
+        // Reserve horizontal space for autonumber badges to the left of participants.
+        // When node shadows are active the SVG filter extends beyond the node boundary,
+        // which can visually encroach on the badge. Add clearance proportional to
+        // ShadowBlur so the badge remains visible across all shadow themes.
+        bool hasAutonumber = diagram.Metadata.ContainsKey("sequence:autonumber");
+        double shadowExtra = theme.UseNodeShadows ? SequenceAutonumberShadowClearanceMultiplier * theme.ShadowBlur : 0.0;
+        double autonumberExtraLeft = hasAutonumber ? SequenceAutonumberBadgeExtraLeft + shadowExtra : 0;
+
+        double runX = pad + autonumberExtraLeft;
         double participantStripHeight = ordered.Max(node => node.Height);
         foreach (var node in ordered)
         {
@@ -43,6 +61,9 @@ private static void LayoutSequenceDiagram(
         double firstMessageY = pad + headingOffset + participantStripHeight + vGap / 2;
         double messageRowHeight = vGap;
 
+        if (hasAutonumber)
+            diagram.Metadata["sequence:autonumberBadgeX"] = pad + autonumberExtraLeft / 2;
+
         // Self-messages (source == target) need 2× the normal row height to
         // accommodate a loopback arc. Walk edges in message-index order so that
         // the running-Y accumulates correctly regardless of storage order.

src/DiagramForge/Parsers/Mermaid/MermaidSequenceParser.cs

@@ -27,6 +27,8 @@ public Diagram Parse(MermaidDocument document)
         var participants = new Dictionary<string, Node>(StringComparer.Ordinal);
         int participantIndex = 0;
         int messageIndex = 0;
+        bool autonumber = false;
+        int autonumberIndex = 1;
 
         // Stack for open rect blocks: each entry holds (group, startMessageIndex).
         var openRects = new Stack<(Group Group, int StartIndex)>();
@@ -48,6 +50,13 @@ Node GetOrCreateParticipant(string id)
         {
             var line = document.Lines[i];
 
+            // autonumber — enable numbered badges on each message
+            if (line.Equals("autonumber", StringComparison.OrdinalIgnoreCase))
+            {
+                autonumber = true;
+                continue;
+            }
+
             // title: <text>  — diagram title directive
             if (line.StartsWith("title:", StringComparison.OrdinalIgnoreCase))
             {
@@ -136,14 +145,20 @@ Node GetOrCreateParticipant(string id)
                 };
                 edge.Metadata["sequence:messageIndex"] = messageIndex++;
 
+                if (autonumber)
+                    edge.Metadata["sequence:autonumberIndex"] = autonumberIndex++;
+
                 if (!string.IsNullOrEmpty(msgLabel))
                     edge.Label = new Label(msgLabel!);
 
                 builder.AddEdge(edge);
             }
         }
 
-        return builder.Build();
+        var diagram = builder.Build();
+        if (autonumber)
+            diagram.Metadata["sequence:autonumber"] = true;
+        return diagram;
     }
 
     /// <summary>

src/DiagramForge/Rendering/SvgRenderer.cs

@@ -152,6 +152,10 @@ int GetGroupDepth(Group group, HashSet<string>? visiting = null)
             SvgStructureWriter.AppendEdge(sb, edge, source, target, theme, diagram.LayoutHints);
         }
 
+        // Sequence-diagram autonumber badges: numbered circles rendered over arrows but under nodes.
+        if (diagram.Metadata.ContainsKey("sequence:autonumber"))
+            SvgStructureWriter.AppendSequenceAutonumberBadges(sb, diagram, theme);
+
         // Nodes (pass index for palette cycling)
         int nodeIndex = 0;
         foreach (var node in diagram.Nodes.Values)

src/DiagramForge/Rendering/SvgStructureWriter.cs

@@ -699,6 +699,43 @@ internal static void AppendLifelines(StringBuilder sb, Diagram diagram, Theme th
         }
     }
 
+    internal static void AppendSequenceAutonumberBadges(StringBuilder sb, Diagram diagram, Theme theme)
+    {
+        if (!diagram.Metadata.TryGetValue("sequence:autonumberBadgeX", out var badgeXObj))
+            return;
+
+        double badgeX = Convert.ToDouble(badgeXObj, System.Globalization.CultureInfo.InvariantCulture);
+        const double BadgeRadius = 12;
+        string fillColor = SvgRenderSupport.Escape(theme.AccentColor);
+        string textColor = SvgRenderSupport.Escape(ColorUtils.IsLight(theme.AccentColor) ? "#0F172A" : "#FFFFFF");
+        string fontFamily = SvgRenderSupport.Escape(theme.FontFamily);
+        double fontSize = theme.FontSize * 0.78;
+
+        foreach (var edge in diagram.Edges)
+        {
+            if (!edge.Metadata.TryGetValue("sequence:messageY", out var msgYObj))
+                continue;
+
+            if (!edge.Metadata.TryGetValue("sequence:autonumberIndex", out var numObj))
+                continue;
+
+            double msgY = Convert.ToDouble(msgYObj, System.Globalization.CultureInfo.InvariantCulture);
+            int num = Convert.ToInt32(numObj, System.Globalization.CultureInfo.InvariantCulture);
+
+            // Self-messages span 2× the row height; vertically center the badge in that range.
+            double badgeY = msgY;
+            if (edge.Metadata.TryGetValue("sequence:selfMessage", out var selfMsgObj) && selfMsgObj is true)
+            {
+                double selfH = TryGetMetadataDouble(edge.Metadata, "sequence:selfMessageHeight", out var ah) ? ah : 40;
+                badgeY = msgY + selfH / 2;
+            }
+
+            string numText = SvgRenderSupport.Escape(num.ToString(System.Globalization.CultureInfo.InvariantCulture));
+            sb.AppendLine($"""  <circle cx="{SvgRenderSupport.F(badgeX)}" cy="{SvgRenderSupport.F(badgeY)}" r="{SvgRenderSupport.F(BadgeRadius)}" fill="{fillColor}"/>""");
+            sb.AppendLine($"""  <text x="{SvgRenderSupport.F(badgeX)}" y="{SvgRenderSupport.F(badgeY + fontSize * 0.38)}" text-anchor="middle" font-family="{fontFamily}" font-size="{SvgRenderSupport.F(fontSize)}" fill="{textColor}" font-weight="600">{numText}</text>""");
+        }
+    }
+
     internal static void AppendXyChartAxes(StringBuilder sb, Diagram diagram, Theme theme)
     {
         double chartX = Convert.ToDouble(diagram.Metadata["xychart:chartX"], System.Globalization.CultureInfo.InvariantCulture);

tests/DiagramForge.E2ETests/Fixtures/mermaid-sequence-autonumber.expected.svg

@@ -0,0 +1,12 @@
+---
+theme: dark
+---
+sequenceDiagram
+    autonumber
+    participant A as Alice
+    participant B as Bob
+    A->>B: Login request
+    B-->>A: Challenge
+    A->>B: Credentials
+    B-->>A: Token
+    A->>A: Store token

tests/DiagramForge.E2ETests/Fixtures/mermaid-sequence-autonumber.input

@@ -326,6 +326,99 @@ public void Parse_TitleAndSubtitleDirectives_DoNotCreateParticipants()
         Assert.True(diagram.Nodes.ContainsKey("B"));
     }
 
+    // ── Autonumber ────────────────────────────────────────────────────────────
+
+    [Fact]
+    public void Parse_Autonumber_SetsDiagramMetadata()
+    {
+        var diagram = _parser.Parse("sequenceDiagram\n    autonumber\n    A->>B: Hello");
+
+        Assert.True(diagram.Metadata.ContainsKey("sequence:autonumber"));
+        Assert.True(diagram.Metadata["sequence:autonumber"] is true);
+    }
+
+    [Fact]
+    public void Parse_Autonumber_CaseInsensitive()
+    {
+        var diagram = _parser.Parse("sequenceDiagram\n    AUTONUMBER\n    A->>B: Hello");
+
+        Assert.True(diagram.Metadata.ContainsKey("sequence:autonumber"));
+    }
+
+    [Fact]
+    public void Parse_Autonumber_EdgeHasAutonumberIndex()
+    {
+        var diagram = _parser.Parse("sequenceDiagram\n    autonumber\n    A->>B: Hello");
+
+        var edge = Assert.Single(diagram.Edges);
+        Assert.True(edge.Metadata.ContainsKey("sequence:autonumberIndex"));
+        Assert.Equal(1, Convert.ToInt32(edge.Metadata["sequence:autonumberIndex"],
+            System.Globalization.CultureInfo.InvariantCulture));
+    }
+
+    [Fact]
+    public void Parse_Autonumber_MultipleMessages_IndexesStartAtOne()
+    {
+        const string text = """
+            sequenceDiagram
+                autonumber
+                A->>B: First
+                B-->>A: Second
+                A->>B: Third
+            """;
+
+        var diagram = _parser.Parse(text);
+
+        Assert.Equal(3, diagram.Edges.Count);
+        for (int i = 0; i < diagram.Edges.Count; i++)
+        {
+            int idx = Convert.ToInt32(diagram.Edges[i].Metadata["sequence:autonumberIndex"],
+                System.Globalization.CultureInfo.InvariantCulture);
+            Assert.Equal(i + 1, idx);
+        }
+    }
+
+    [Fact]
+    public void Parse_NoAutonumber_DiagramMetadataKeyAbsent()
+    {
+        var diagram = _parser.Parse("sequenceDiagram\n    A->>B: Hello");
+
+        Assert.False(diagram.Metadata.ContainsKey("sequence:autonumber"));
+    }
+
+    [Fact]
+    public void Parse_NoAutonumber_EdgeDoesNotHaveAutonumberIndex()
+    {
+        var diagram = _parser.Parse("sequenceDiagram\n    A->>B: Hello");
+
+        var edge = Assert.Single(diagram.Edges);
+        Assert.False(edge.Metadata.ContainsKey("sequence:autonumberIndex"));
+    }
+
+    [Fact]
+    public void Parse_Autonumber_MessagesBeforeKeyword_AreNotNumbered()
+    {
+        const string text = """
+            sequenceDiagram
+                A->>B: Before
+                autonumber
+                B-->>A: After
+            """;
+
+        var diagram = _parser.Parse(text);
+
+        Assert.Equal(2, diagram.Edges.Count);
+        // Find edge with label "Before" — it should have no autonumber index
+        var beforeEdge = diagram.Edges.First(e => e.Label?.Text == "Before");
+        Assert.False(beforeEdge.Metadata.ContainsKey("sequence:autonumberIndex"));
+
+        // Find edge with label "After" — it should be numbered 1
+        var afterEdge = diagram.Edges.First(e => e.Label?.Text == "After");
+        Assert.True(afterEdge.Metadata.ContainsKey("sequence:autonumberIndex"));
+        Assert.Equal(1, Convert.ToInt32(afterEdge.Metadata["sequence:autonumberIndex"],
+            System.Globalization.CultureInfo.InvariantCulture));
+    }
+
     // ── Rect blocks ───────────────────────────────────────────────────────────
 
     [Fact]