fix: preserve enum split branch order in staged builder

Symptom: enum split roundtrips could reorder an explicit `(empty)` case after named cases, and an empty-body grouped case could move behind a terminal branch.

Root cause: the staged enum split builder selected split-flow anchors from branch geometry. `(empty)` branches used bottom-origin geometry, and empty-body branch tails were emitted after body branches, so the describer could not recover the original authoring order.

Fix: carry the authoring branch index onto empty-body tails, encode the first split flow of order-sensitive branches using the existing split-case order anchors, and sort enum split flows by that encoded order before grouping cases during describe.

Tests: added synthetic enum split regressions for `(empty)` before named cases and grouped empty-body cases before terminal cases; ran make build, make test, make lint-go, and a targeted two-microflow audit with clean mxcli and Mendix mx check results.

Author: hjothamendix

mdl/executor/cmd_microflows_builder_actions.go

@@ -292,6 +292,7 @@ func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
 		id        model.ID
 		values    []string
 		fromSplit bool
+		order     int
 	}
 	var branchTails []branchTail
 	routePendingErrorToElse := len(s.ElseBody) > 0 && fb.errorHandlerSkipVar != "" && s.Variable == fb.errorHandlerSkipVar
@@ -303,7 +304,7 @@ func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
 		branchIndex++
 		if len(body) == 0 {
 			allBranchesReturn = false
-			branchTails = append(branchTails, branchTail{id: splitID, values: values, fromSplit: true})
+			branchTails = append(branchTails, branchTail{id: splitID, values: values, fromSplit: true, order: branchNumber})
 			return
 		}
 
@@ -366,6 +367,9 @@ func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
 				}
 				baseDestinationAnchor := flow.DestinationConnectionIndex
 				if branchEntryIsSplit {
+					if len(values) <= 1 && (thisAnchor == nil || thisAnchor.To == ast.AnchorSideUnset) {
+						applySplitCaseOrder(flow, branchNumber)
+					}
 					applyEnumGroupedControlVectors(flow, 0, len(values))
 				}
 				fb.flows = append(fb.flows, flow)
@@ -463,6 +467,7 @@ func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
 				} else {
 					flow = newDownwardFlowWithEnumCase(splitID, merge.ID, enumSplitFlowCaseValue(tail.values, 0))
 				}
+				applySplitCaseOrder(flow, tail.order)
 				baseDestinationAnchor := flow.DestinationConnectionIndex
 				applyEnumGroupedControlVectors(flow, 0, len(tail.values))
 				fb.flows = append(fb.flows, flow)
@@ -524,6 +529,39 @@ func enumSplitGroupedDestinationAnchor(baseAnchor, index int) int {
 	return baseAnchor
 }
 
+type splitCaseOrderAnchor struct {
+	origin      int
+	destination int
+}
+
+var splitCaseOrderAnchors = []splitCaseOrderAnchor{
+	{AnchorTop, AnchorLeft},
+	{AnchorRight, AnchorLeft},
+	{AnchorBottom, AnchorLeft},
+	{AnchorLeft, AnchorLeft},
+	{AnchorTop, AnchorTop},
+	{AnchorRight, AnchorTop},
+	{AnchorBottom, AnchorTop},
+	{AnchorLeft, AnchorTop},
+	{AnchorTop, AnchorRight},
+	{AnchorRight, AnchorRight},
+	{AnchorBottom, AnchorRight},
+	{AnchorLeft, AnchorRight},
+	{AnchorTop, AnchorBottom},
+	{AnchorRight, AnchorBottom},
+	{AnchorBottom, AnchorBottom},
+	{AnchorLeft, AnchorBottom},
+}
+
+func applySplitCaseOrder(flow *microflows.SequenceFlow, order int) {
+	if flow == nil || order < 0 || order >= len(splitCaseOrderAnchors) {
+		return
+	}
+	pair := splitCaseOrderAnchors[order]
+	flow.OriginConnectionIndex = pair.origin
+	flow.DestinationConnectionIndex = pair.destination
+}
+
 func applyEnumGroupedControlVectors(flow *microflows.SequenceFlow, index, total int) {
 	if flow == nil || total == 0 {
 		return

mdl/executor/cmd_microflows_builder_enum_split_test.go

@@ -3,6 +3,7 @@
 package executor
 
 import (
+	"strings"
 	"testing"
 
 	"github.com/mendixlabs/mxcli/mdl/ast"
@@ -156,6 +157,86 @@ func TestBuildFlowGraph_EnumSplitGroupedCasesShareDestination(t *testing.T) {
 	}
 }
 
+func TestBuildFlowGraph_EnumSplitPreservesEmptyCaseBeforeNamedCases(t *testing.T) {
+	out := describeBuiltEnumSplitBody(t, []ast.MicroflowStatement{
+		&ast.EnumSplitStmt{
+			Variable: "ImageKind",
+			Cases: []ast.EnumSplitCase{
+				{
+					Value: "(empty)",
+					Body: []ast.MicroflowStatement{
+						&ast.LogStmt{
+							Level:       ast.LogError,
+							Message:     &ast.LiteralExpr{Kind: ast.LiteralString, Value: "missing kind"},
+							Annotations: &ast.ActivityAnnotations{Position: &ast.Position{X: -300, Y: -200}},
+						},
+					},
+				},
+				{
+					Value: "Cover",
+					Body: []ast.MicroflowStatement{
+						&ast.LogStmt{
+							Level:       ast.LogInfo,
+							Message:     &ast.LiteralExpr{Kind: ast.LiteralString, Value: "cover"},
+							Annotations: &ast.ActivityAnnotations{Position: &ast.Position{X: -300, Y: 100}},
+						},
+					},
+				},
+				{
+					Value: "Logo",
+					Body: []ast.MicroflowStatement{
+						&ast.LogStmt{
+							Level:       ast.LogInfo,
+							Message:     &ast.LiteralExpr{Kind: ast.LiteralString, Value: "logo"},
+							Annotations: &ast.ActivityAnnotations{Position: &ast.Position{X: -300, Y: -40}},
+						},
+					},
+				},
+			},
+		},
+	})
+
+	assertTextOrder(t, out, "case (empty)", "case Cover", "case Logo")
+}
+
+func TestBuildFlowGraph_EnumSplitPreservesEmptyBodyCaseOrder(t *testing.T) {
+	out := describeBuiltEnumSplitBody(t, []ast.MicroflowStatement{
+		&ast.EnumSplitStmt{
+			Variable: "Event/Type",
+			Cases: []ast.EnumSplitCase{
+				{
+					Values: []string{"CREATE", "DELETE"},
+				},
+				{
+					Value: "UPDATE",
+					Body: []ast.MicroflowStatement{
+						&ast.LogStmt{Level: ast.LogInfo, Message: &ast.LiteralExpr{Kind: ast.LiteralString, Value: "update"}},
+						&ast.ReturnStmt{},
+					},
+				},
+				{
+					Value: "(empty)",
+					Body: []ast.MicroflowStatement{
+						&ast.LogStmt{
+							Level:   ast.LogInfo,
+							Message: &ast.LiteralExpr{Kind: ast.LiteralString, Value: "empty"},
+							Annotations: &ast.ActivityAnnotations{
+								Anchor: &ast.FlowAnchors{From: ast.AnchorSideBottom, To: ast.AnchorSideTop},
+							},
+						},
+						&ast.ReturnStmt{
+							Annotations: &ast.ActivityAnnotations{Anchor: &ast.FlowAnchors{To: ast.AnchorSideTop}},
+						},
+					},
+				},
+			},
+		},
+		&ast.LogStmt{Level: ast.LogInfo, Message: &ast.LiteralExpr{Kind: ast.LiteralString, Value: "shared tail"}},
+	})
+
+	assertTextOrder(t, out, "case CREATE, DELETE", "case UPDATE", "case (empty)")
+}
+
 func TestBuildFlowGraph_EnumSplitAllTerminalCasesDoesNotAddDefaultFlow(t *testing.T) {
 	body := []ast.MicroflowStatement{
 		&ast.EnumSplitStmt{
@@ -200,6 +281,33 @@ func TestBuildFlowGraph_EnumSplitAllTerminalCasesDoesNotAddDefaultFlow(t *testin
 	}
 }
 
+func describeBuiltEnumSplitBody(t *testing.T, body []ast.MicroflowStatement) string {
+	t.Helper()
+
+	fb := &flowBuilder{posX: 100, posY: 100, spacing: HorizontalSpacing, measurer: &layoutMeasurer{}}
+	oc := fb.buildFlowGraph(body, nil)
+	mf := &microflows.Microflow{ObjectCollection: oc}
+	e := newTestExecutor()
+
+	return strings.Join(formatMicroflowActivities(e.newExecContext(t.Context()), mf, nil, nil), "\n")
+}
+
+func assertTextOrder(t *testing.T, out string, items ...string) {
+	t.Helper()
+
+	lastIdx := -1
+	for _, item := range items {
+		idx := strings.Index(out, item)
+		if idx == -1 {
+			t.Fatalf("missing %q in output:\n%s", item, out)
+		}
+		if idx < lastIdx {
+			t.Fatalf("expected %q after previous item in output:\n%s", item, out)
+		}
+		lastIdx = idx
+	}
+}
+
 func TestBuildFlowGraph_EnumSplitSiblingBranchesDeclareRepeatedCallOutputs(t *testing.T) {
 	body := []ast.MicroflowStatement{
 		&ast.EnumSplitStmt{

mdl/executor/cmd_microflows_show_helpers.go

@@ -6,6 +6,7 @@ package executor
 import (
 	"context"
 	"fmt"
+	"sort"
 	"strings"
 
 	"github.com/mendixlabs/mxcli/model"
@@ -1047,7 +1048,7 @@ func emitEnumSplitStatement(
 	var branches []enumBranch
 	branchByDestination := make(map[model.ID]int)
 	var elseFlow *microflows.SequenceFlow
-	for _, flow := range findNormalFlows(flowsByOrigin[currentID]) {
+	for _, flow := range orderedEnumSplitFlows(findNormalFlows(flowsByOrigin[currentID])) {
 		caseValue, isEnum := enumCaseValue(flow.CaseValue)
 		if !isEnum {
 			if isNoCaseValue(flow.CaseValue) {
@@ -1141,6 +1142,26 @@ func enumCaseValue(cv microflows.CaseValue) (string, bool) {
 	}
 }
 
+func orderedEnumSplitFlows(flows []*microflows.SequenceFlow) []*microflows.SequenceFlow {
+	ordered := append([]*microflows.SequenceFlow(nil), flows...)
+	sort.SliceStable(ordered, func(i, j int) bool {
+		return splitCaseOrder(ordered[i]) < splitCaseOrder(ordered[j])
+	})
+	return ordered
+}
+
+func splitCaseOrder(flow *microflows.SequenceFlow) int {
+	if flow == nil {
+		return 1 << 20
+	}
+	for i, pair := range splitCaseOrderAnchors {
+		if flow.OriginConnectionIndex == pair.origin && flow.DestinationConnectionIndex == pair.destination {
+			return i
+		}
+	}
+	return (1 << 10) + flow.OriginConnectionIndex*4 + flow.DestinationConnectionIndex
+}
+
 func isNoCaseValue(cv microflows.CaseValue) bool {
 	switch cv.(type) {
 	case *microflows.NoCase, microflows.NoCase: