fix: preserve @anchor on first statement of enum split cases

The enum split builder's case body loop never called stmtOwnAnchor
on its statements, so any @anchor(from: …, to: …) authored on the
first activity in a case silently dropped on exec. Describe → exec
→ describe stripped the FlowAnchor entirely because the split →
first-case-activity flow carried only layout-default connection
indices.

Mirror the existing IF and inheritance-split case body loops by:

- capturing thisAnchor = stmtOwnAnchor(stmt) at the top of each
  iteration;
- applying it to the split → first-case-activity flow (the last
  flow that addGroupedEnumSplitFlows appended for the case value);
- carrying prevAnchor across subsequent statements and applying
  applyUserAnchors(flow, prevAnchor, thisAnchor) on each
  intra-case flow.

Test: TestEnumSplitBuilderPreservesFirstStatementAnchor asserts
that @anchor(to: bottom) on the first case statement lands on
the split → case flow's DestinationConnectionIndex.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hjothamendix

mdl/executor/cmd_microflows_builder_actions.go

@@ -360,7 +360,9 @@ func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
 
 		lastID := model.ID("")
 		pendingCase := ""
+		var prevAnchor *ast.FlowAnchors
 		for _, stmt := range br.body {
+			thisAnchor := stmtOwnAnchor(stmt)
 			actID := fb.addStatement(stmt)
 			if actID == "" {
 				continue
@@ -371,14 +373,26 @@ func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
 			}
 			if lastID == "" {
 				fb.addGroupedEnumSplitFlows(splitID, actID, br.values, i, splitX+SplitWidth+HorizontalSpacing/4, branchY)
+				// The first statement in a case can carry @anchor(from:…,
+				// to:…) that should apply to the split→firstActivity flow.
+				// addGroupedEnumSplitFlows appends one flow per case value;
+				// anchor the last one so `@anchor(to: top)` etc. round-trips
+				// through describe → exec without silently dropping.
+				if thisAnchor != nil && len(fb.flows) > 0 {
+					applyUserAnchors(fb.flows[len(fb.flows)-1], nil, thisAnchor)
+				}
 			} else {
+				var flow *microflows.SequenceFlow
 				if pendingCase != "" {
-					fb.flows = append(fb.flows, newHorizontalFlowWithCase(lastID, actID, pendingCase))
+					flow = newHorizontalFlowWithCase(lastID, actID, pendingCase)
 					pendingCase = ""
 				} else {
-					fb.flows = append(fb.flows, newHorizontalFlow(lastID, actID))
+					flow = newHorizontalFlow(lastID, actID)
 				}
+				applyUserAnchors(flow, prevAnchor, thisAnchor)
+				fb.flows = append(fb.flows, flow)
 			}
+			prevAnchor = thisAnchor
 			if fb.nextConnectionPoint != "" {
 				lastID = fb.nextConnectionPoint
 				fb.nextConnectionPoint = ""

mdl/executor/cmd_microflows_builder_enum_split_test.go

@@ -245,3 +245,63 @@ func enumSplitWithBranchCount(count int) *ast.EnumSplitStmt {
 		Cases:    cases,
 	}
 }
+
+// TestEnumSplitBuilderPreservesFirstStatementAnchor guards against silent
+// loss of @anchor(from:..., to:...) on the first statement inside an enum
+// split case. Before the fix the enum split builder never read
+// stmtOwnAnchor(stmt) for case bodies, so any round-tripped anchor dropped
+// on re-exec — describe → exec → describe lost the FlowAnchor entirely.
+func TestEnumSplitBuilderPreservesFirstStatementAnchor(t *testing.T) {
+	fb := &flowBuilder{
+		spacing:  HorizontalSpacing,
+		measurer: &layoutMeasurer{},
+	}
+
+	// @anchor(to: bottom) on the first case statement — bottom is a
+	// non-default destination anchor (AnchorSideBottom == 2) so we can
+	// distinguish it from the layout default.
+	anchor := &ast.FlowAnchors{
+		From: ast.AnchorSideUnset,
+		To:   ast.AnchorSideBottom,
+	}
+	fb.addEnumSplit(&ast.EnumSplitStmt{
+		Variable: "Status",
+		Cases: []ast.EnumSplitCase{
+			{
+				Values: []string{"Open"},
+				Body: []ast.MicroflowStatement{
+					&ast.LogStmt{
+						Level:       ast.LogInfo,
+						Message:     &ast.LiteralExpr{Kind: ast.LiteralString, Value: "open"},
+						Annotations: &ast.ActivityAnnotations{Anchor: anchor},
+					},
+				},
+			},
+		},
+	})
+
+	var split *microflows.ExclusiveSplit
+	for _, obj := range fb.objects {
+		if s, ok := obj.(*microflows.ExclusiveSplit); ok {
+			split = s
+			break
+		}
+	}
+	if split == nil {
+		t.Fatal("expected ExclusiveSplit")
+	}
+
+	var firstCaseFlow *microflows.SequenceFlow
+	for _, f := range fb.flows {
+		if f.OriginID == split.ID {
+			firstCaseFlow = f
+		}
+	}
+	if firstCaseFlow == nil {
+		t.Fatal("expected split→case flow")
+	}
+	if firstCaseFlow.DestinationConnectionIndex != int(ast.AnchorSideBottom) {
+		t.Errorf("DestinationConnectionIndex = %d, want %d — @anchor(to: bottom) was dropped",
+			firstCaseFlow.DestinationConnectionIndex, int(ast.AnchorSideBottom))
+	}
+}